[Feature Request] Integration of Agent Protocol from AI-Engineer-Foundation into Langflow

[YAMON.IO]

Reason for Suggestion:

Integrating the Agent Protocol from AI-Engineer-Foundation into Langflow will standardize communication with different agents, enhancing interoperability and simplifying the development process. This will facilitate easier benchmarking, development, and integration of various agents, thereby accelerating ecosystem growth and improving user experience. Additionally, by making Langflow compatible with the Agent Protocol, it will enable seamless interaction with other projects like AUTO-GPT, allowing users to easily call agents from different solutions and integrate Langflow's flows (agents) with other compatible solutions.
https://github.com/AI-Engineer-Foundation/agent-protocol

Content of the Proposal:

1. Analyze Langflow Architecture: Examine the current architecture of Langflow to identify points for integrating the Agent Protocol.
2. Implement API Endpoints: Incorporate the necessary API endpoints as specified by the Agent Protocol, including:
   • POST /ap/v1/agent/tasks for creating new tasks
   • POST /ap/v1/agent/tasks/{task_id}/steps for executing task steps
   • Additional routes for listing tasks, steps, and managing artifacts.
3. Ensure Compatibility: Verify compatibility with existing Langflow features and workflows to ensure seamless integration.
4. Develop SDK Support: Utilize the Agent Protocol SDK to facilitate the implementation process and provide a standardized interface for agent communication.
5. Create Documentation: Develop comprehensive documentation and usage examples to assist developers in adopting and utilizing the new integration.
6. Enable Cross-Project Interaction: Ensure that the integration allows for calling agents from other projects like AUTO-GPT and enables Langflow’s flows to be easily called from other compatible solutions.

Technical Considerations:

1. Security and Performance: Ensure that the integration does not introduce any security vulnerabilities or performance bottlenecks.
2. Data Compatibility: Validate the compatibility of data formats and communication protocols between Langflow and the Agent Protocol.
3. Extensive Testing: Conduct thorough testing to guarantee the stability and reliability of the integration.
4. Ongoing Maintenance: Plan for continuous maintenance and updates to accommodate future changes in both Langflow and the Agent Protocol.

Potential Use Cases:

1. Automated Workflows: Automating complex workflows that require coordination between multiple agents.
2. Enhanced Data Processing: Incorporating agent-based decision-making to enhance data processing pipelines.
3. Dynamic System Behavior: Facilitating more dynamic and adaptive system behaviors within Langflow projects.
4. Expanded Integrations: Extending the range of applications and services that can be integrated with Langflow.
5. Cross-Project Integration: Easily calling agents from other projects like AUTO-GPT and allowing Langflow’s flows to be called from other compatible solutions.

[Gabriel Luiz Freitas Almeida]

Hey

That's a good idea!

We have created a new way building a Component and we could adapt the components we have now to support this.

Here's how the ChatInput looks in the new format. What do you think?

from langflow.base.io.chat import ChatComponent
from langflow.field_typing import Text
from langflow.schema import Record
from langflow.template import Input, Output


class ChatInput(ChatComponent):
    display_name = "Chat Input"
    description = "Get chat inputs from the Playground."
    icon = "ChatInput"

    inputs = [
        Input(
            name="input_value",
            type=str,
            display_name="Message",
            multiline=True,
            input_types=[],
            info="Message to be passed as input.",
        ),
        Input(
            name="sender",
            type=str,
            display_name="Sender Type",
            options=["Machine", "User"],
            value="User",
            info="Type of sender.",
            advanced=True,
        ),
        Input(name="sender_name", type=str, display_name="Sender Name", info="Name of the sender.", value="User"),
        Input(
            name="session_id", type=str, display_name="Session ID", info="Session ID for the message.", advanced=True
        ),
    ]
    outputs = [
        Output(display_name="Message", name="message", method="text_response"),
        Output(display_name="Record", name="record", method="record_response"),
    ]

    def text_response(self) -> Text:
        result = self.input_value
        if self.session_id and isinstance(result, (Record, str)):
            self.store_message(result, self.session_id, self.sender, self.sender_name)
        return result

    def record_response(self) -> Record:
        record = Record(
            data={
                "text": self.input_value,
                "sender": self.sender,
                "sender_name": self.sender_name,
                "session_id": self.session_id,
            },
        )
        if self.session_id and isinstance(record, (Record, str)):
            self.store_message(record, self.session_id, self.sender, self.sender_name)
        return record

[YAMON.IO]

Hey

That's a good idea!

We have created a new way building a Component and we could adapt the components we have now to support this.

Here's how the ChatInput looks in the new format. What do you think?

from langflow.base.io.chat import ChatComponent
from langflow.field_typing import Text
from langflow.schema import Record
from langflow.template import Input, Output


class ChatInput(ChatComponent):
    display_name = "Chat Input"
    description = "Get chat inputs from the Playground."
    icon = "ChatInput"

    inputs = [
        Input(
            name="input_value",
            type=str,
            display_name="Message",
            multiline=True,
            input_types=[],
            info="Message to be passed as input.",
        ),
        Input(
            name="sender",
            type=str,
            display_name="Sender Type",
            options=["Machine", "User"],
            value="User",
            info="Type of sender.",
            advanced=True,
        ),
        Input(name="sender_name", type=str, display_name="Sender Name", info="Name of the sender.", value="User"),
        Input(
            name="session_id", type=str, display_name="Session ID", info="Session ID for the message.", advanced=True
        ),
    ]
    outputs = [
        Output(display_name="Message", name="message", method="text_response"),
        Output(display_name="Record", name="record", method="record_response"),
    ]

    def text_response(self) -> Text:
        result = self.input_value
        if self.session_id and isinstance(result, (Record, str)):
            self.store_message(result, self.session_id, self.sender, self.sender_name)
        return result

    def record_response(self) -> Record:
        record = Record(
            data={
                "text": self.input_value,
                "sender": self.sender,
                "sender_name": self.sender_name,
                "session_id": self.session_id,
            },
        )
        if self.session_id and isinstance(record, (Record, str)):
            self.store_message(record, self.session_id, self.sender, self.sender_name)
        return record

---

@ogabrielluiz Hello!,

Thank you for the response. I was in the middle of development, and this is exactly the structure I was looking for!

Managing INPUT and OUTPUT as templates in this manner should make it easy to connect with various solutions, not just Agent Protocol.

It seems like there's someone trying to integrate Agent Protocol with Langchain and is currently working on it, but instead of waiting for that work, considering future integration with solutions like Lammaindex, Langflow itself will need IO templates that are integrated as templates.

(You came up with a great idea at the perfect time!)

Additionally, in the case of Agent Protocol, there is a concept of adding or downloading files as artifacts. This structure should also be predefined in the parent ChatComponent.

At this stage, since it seems like only the AUTOGPT team is actively integrating the Agent Protocol client, the structure needed for the artifact concept might not be immediately necessary.

[YAMON.IO]

After reviewing the progress and design of this repository over the past few weeks, it seems like a project with no future. It appears to be an implementation that doesn't even meet the basic design standards of Langraph or CrewAI, so I am withdrawing my proposal.