aip-agents-binary 0.5.20__py3-none-any.whl

aip_agents/examples/hello_world_a2a_langgraph_client_streaming_tool_streaming.py

@@ -0,0 +1,92 @@
+"""Example of a General Assistant LangChainAgent that delegates time and weather tasks to specialized agents.
+
+This example demonstrates:
+1. Configuring A2A settings for a client agent to connect to time/weather services.
+2. Creating a general assistant agent that can help with time and weather queries.
+3. Delegating specific time and weather tasks to specialized agents via A2A with streaming.
+4. Handling streaming responses from time and weather tasks.
+5. Real-time display of time and weather information and agent thinking process.
+
+The client requests the time/weather agent to get current time and weather forecast,
+demonstrating streaming capabilities of the LangGraph agent wrapper.
+
+To run this example:
+1. First start the time/weather agent server:
+   python examples/hello_world_a2a_langgraph_server_tool_streaming.py --port 8003
+2. Then run this client:
+   python examples/hello_world_a2a_langgraph_client_streaming_tool_streaming.py
+
+Environment Variables Required:
+    OPENAI_API_KEY: OpenAI API key for the LLM
+
+Authors:
+    Fachriza Adhiatma (fachriza.d.adhiatma@gdplabs.id)
+"""
+
+import asyncio
+from pprint import pprint
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.schema.agent import A2AClientConfig
+
+
+async def main():
+    """Main function demonstrating the General Assistant agent with streaming A2A time/weather capabilities."""
+    print("🚀 Starting Time & Weather Agent Client Demo")
+    print("=" * 60)
+
+    # Create a general assistant agent
+    agent = LangChainAgent(
+        name="TimeWeatherAssistantAgentLangChain",
+        instruction="""You are a helpful assistant that can help with various tasks
+        by delegating to specialized agents. You have access to time and weather
+        agents that can provide current time information and weather data
+        for specific cities.
+
+        When users ask for time or weather-related tasks, delegate them to the
+        time/weather agent. Provide clear summaries of the results and help
+        interpret the information that's provided.""",
+        model="openai/gpt-4o",
+    )
+
+    # Configure A2A client to discover time/weather agents
+    client_a2a_config = A2AClientConfig(
+        discovery_urls=["http://localhost:8003"],  # Time/weather agent server
+    )
+
+    print("🔍 Discovering available time & weather agents...")
+    try:
+        agent_cards = agent.discover_agents(client_a2a_config)
+
+        if not agent_cards:
+            print("❌ No time & weather agents found!")
+            print("   Make sure the agent server is running on http://localhost:8003")
+            return
+
+        print(f"✅ Found {len(agent_cards)} time & weather agent(s)")
+
+        for i, card in enumerate(agent_cards):
+            print(f"   {i + 1}. {card.name}: {card.description}")
+            if card.skills:
+                print(f"      Skills: {', '.join([skill.name for skill in card.skills])}")
+
+        task = "what time is it and what is the weather in jakarta?"
+
+        print(f"📝 Task: {task}")
+
+        async for chunk in agent.astream_to_agent(agent_card=agent_cards[0], message=task):
+            print("-" * 40)
+            pprint(chunk)
+
+        print("\n" + "=" * 60)
+        print("\n🎉 Time & Weather agent task finished!")
+
+    except Exception as e:
+        print(f"❌ Error during time & weather query: {str(e)}")
+        print("   Make sure:")
+        print("   1. The time & weather server is running (python hello_world_a2a_langgraph_server_agent_wrapper.py)")
+        print("   2. OPENAI_API_KEY is set in your environment")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_a2a_langgraph_server.py

@@ -0,0 +1,84 @@
+"""Example A2A server for a LangGraphAgent Weather Service.
+
+This server instantiates a LangGraphAgent with weather lookup capabilities and serves it
+via the A2A protocol using the proper A2A server setup with LangGraphA2AExecutor.
+
+To run this server:
+    python examples/hello_world_a2a_langgraph_server.py
+
+It will listen on http://localhost:8001 by default.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.tools import weather_tool_langchain as weather_tool
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+SERVER_AGENT_NAME = "WeatherAgent"
+
+
+@click.command()
+@click.option("--host", "host", default="localhost", help="Host to bind the server to.")
+@click.option("--port", "port", default=8001, help="Port to bind the server to.")
+def main(host: str, port: int):
+    """Runs the LangGraph Weather A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description="A weather agent that provides weather information for cities.",
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="weather",
+                name="Weather Lookup",
+                description="Provides current weather information for cities.",
+                examples=["What's the weather in Tokyo?", "Get weather for London"],
+                tags=["weather"],
+            )
+        ],
+        tags=["weather"],
+    )
+
+    llm = ChatOpenAI(model="gpt-4.1", temperature=0, streaming=True)
+    tools = [weather_tool]
+
+    langgraph_agent = LangGraphAgent(
+        name=SERVER_AGENT_NAME,
+        instruction=(
+            "You are a weather agent that provides weather information for cities. "
+            "Always use the weather_tool for looking up weather data. "
+            "Format your responses clearly and professionally."
+        ),
+        model=llm,
+        tools=tools,
+        enable_a2a_token_streaming=True,
+    )
+
+    app = langgraph_agent.to_a2a(agent_card=agent_card)
+
+    logger.info("A2A application configured. Starting Uvicorn server...")
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_a2a_langgraph_server_lm_invoker.py

@@ -0,0 +1,79 @@
+"""Example A2A server for a LangChainAgent Weather Service.
+
+This server instantiates a LangChainAgent with weather lookup capabilities and serves it
+via the A2A protocol using the to_a2a convenience method.
+
+To run this server:
+    python examples/a2a/langchain_server_example.py
+
+It will listen on http://localhost:8001 by default.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.tools.langchain_weather_tool import weather_tool
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+SERVER_AGENT_NAME = "WeatherAgentLangChain"
+
+
+@click.command()
+@click.option("--host", "host", default="localhost", help="Host to bind the server to.")
+@click.option("--port", "port", default=8001, help="Port to bind the server to.")
+def main(host: str, port: int):
+    """Runs the LangChain Weather A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description="A weather agent that provides weather information for cities",
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="weather",
+                name="Weather Lookup",
+                description="Provides current weather information for cities.",
+                examples=["What's the weather in Tokyo?", "Get weather for London"],
+                tags=["weather"],
+            )
+        ],
+        tags=["weather"],
+    )
+
+    langchain_agent = LangChainAgent(
+        name=SERVER_AGENT_NAME,
+        instruction="""You are a weather agent that provides weather information for cities.
+        Always use the weather_tool for looking up weather data. Format your responses clearly and professionally.""",
+        model="openai/gpt-4o",
+        tools=[weather_tool],
+    )
+
+    app = langchain_agent.to_a2a(
+        agent_card=agent_card,
+    )
+
+    uvicorn.run(app, host=host, port=port)
+    logger.info("A2A application configured. Starting Uvicorn server...")
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_a2a_langgraph_server_tool_streaming.py

@@ -0,0 +1,132 @@
+"""Example A2A server for a LangGraph Agent Wrapper Service.
+
+This server instantiates a LangChainAgent with the LangGraph agent wrapper tool that provides
+time and weather forecast capabilities, and serves it via the A2A protocol with streaming support.
+
+The agent can handle time queries and weather forecast requests for any day of the week.
+
+To run this server:
+    python examples/hello_world_a2a_langgraph_server_tool_streaming.py
+
+It will listen on http://localhost:8003 by default.
+
+Environment Variables Required:
+    OPENAI_API_KEY: OpenAI API key for the LLM
+
+Authors:
+    Fachriza Adhiatma (fachriza.d.adhiatma@gdplabs.id)
+"""
+
+import click
+import uvicorn
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from dotenv import load_dotenv
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.tools.langgraph_streaming_tool import LangGraphStreamingTool
+from aip_agents.utils.logger import get_logger
+
+load_dotenv()
+
+logger = get_logger(__name__)
+
+SERVER_AGENT_NAME = "TimeWeatherAgentLangGraph"
+
+
+@click.command()
+@click.option("--host", "host", default="localhost", help="Host to bind the server to.")
+@click.option("--port", "port", default=8003, help="Port to bind the server to.")
+def main(host: str, port: int):
+    """Runs the LangGraph Agent Wrapper A2A server.
+
+    Args:
+        host (str): Host to bind the server to.
+        port (int): Port to bind the server to.
+    """
+    logger.info(f"Starting {SERVER_AGENT_NAME} on http://{host}:{port}")
+
+    # ruff: noqa: E501
+    agent_card = AgentCard(
+        name=SERVER_AGENT_NAME,
+        description="A time and weather agent that can provide current time information and weather data for specific cities",
+        url=f"http://{host}:{port}",
+        version="1.0.0",
+        defaultInputModes=["text"],
+        defaultOutputModes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[
+            AgentSkill(
+                id="time_queries",
+                name="Time Information",
+                description="Provides current time and date information in various formats.",
+                examples=[
+                    "What time is it now?",
+                    "Get the current date and time",
+                    "Show me the time in ISO format",
+                    "What's the current timestamp?",
+                ],
+                tags=["time", "date", "timestamp"],
+            ),
+            AgentSkill(
+                id="weather_info",
+                name="Weather Information",
+                description="Provides weather information for specific cities.",
+                examples=[
+                    "What's the weather in Jakarta?",
+                    "Weather in Tokyo and Singapore",
+                    "Check weather for New York",
+                    "Get weather for London",
+                ],
+                tags=["weather", "city", "location"],
+            ),
+            AgentSkill(
+                id="combined_queries",
+                name="Time and Weather Combined",
+                description="Handles queries that combine both time and weather information.",
+                examples=[
+                    "What time is it and what's the weather in Jakarta?",
+                    "Current time and weather in Tokyo",
+                    "Tell me the time and weather for Singapore",
+                ],
+                tags=["time", "weather", "combined"],
+            ),
+        ],
+        tags=["time", "weather", "assistant"],
+    )
+
+    # Create the LangGraph streaming tool instance
+    streaming_tool = LangGraphStreamingTool()
+
+    langchain_agent = LangChainAgent(
+        name=SERVER_AGENT_NAME,
+        instruction="""You are a helpful time and weather assistant.
+
+You can provide current time information and weather forecasts.
+
+You have access to a specialized LangGraph agent that can:
+- Get the current time and date in various formats
+- Provide weather information for specific cities (Jakarta, Singapore, Tokyo, London, New York)
+- Handle combined time and weather queries
+
+When given a task:
+1. Use the langgraph_streaming_tool to execute time and weather queries
+2. Be specific about what information is requested
+3. Provide clear, formatted responses about the time or weather information
+4. For weather queries, specify the city name clearly
+
+Always use the agent wrapper tool for time and weather requests. Format your responses clearly and professionally.""",
+        model="openai/gpt-4.1",
+        tools=[streaming_tool],
+        tool_configs={"langgraph_streaming_tool": {"time_format": "%d-%m-%Y %H:%M:%S"}},
+    )
+
+    app = langchain_agent.to_a2a(
+        agent_card=agent_card,
+    )
+
+    uvicorn.run(app, host=host, port=port)
+    logger.info("A2A application configured. Starting Uvicorn server...")
+
+
+if __name__ == "__main__":
+    main()

aip_agents/examples/hello_world_a2a_mcp_langgraph.py

@@ -0,0 +1,196 @@
+"""Example demonstrating integration of A2A and MCP servers with LangGraphAgent.
+
+This script shows how to create a LangGraphAgent that connects to:
+1. An MCP server with weather forecast tool (must be running on port 8000)
+2. An A2A server with weather capabilities (must be running on port 8001)
+
+To run this example:
+1. Start the MCP server: python aip_agents/examples/mcp_servers/mcp_server_sse.py
+2. Start the A2A server: python aip_agents/examples/hello_world_a2a_langgraph_server.py
+3. Set your OPENAI_API_KEY environment variable
+4. Run this script: python examples/hello_world_a2a_mcp_langgraph.py
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import asyncio
+import os
+import sys
+import traceback
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.schema.agent import A2AClientConfig
+
+# Configuration
+A2A_SERVER_PORT = 8002  # Port for StockAgent A2A server
+A2A_AGENT_NAME = "StockAgent"  # Must match the agent name in A2A server
+MCP_SERVER_PORT = 8000  # Port for MCP server (weather tools)
+MCP_AGENT_NAME = "weather_tools"  # Must match the agent name in MCP server
+MODEL_NAME = "gpt-4.1"
+
+
+async def create_agent() -> tuple[LangGraphAgent, dict[str, bool]]:
+    """Create and configure the LangGraphAgent with MCP and A2A connections.
+
+    Returns:
+        tuple: (agent, connected_servers) where connected_servers is a dict
+        showing which servers were successfully connected.
+    """
+    if not os.getenv("OPENAI_API_KEY"):
+        raise ValueError("OPENAI_API_KEY environment variable not set")
+
+    print("\nCreating LangGraphAgent...")
+    llm = ChatOpenAI(model=MODEL_NAME, temperature=0, openai_api_key=os.getenv("OPENAI_API_KEY"))
+
+    agent = LangGraphAgent(
+        name="IntegrationAgent",
+        instruction="""You are a helpful assistant that can use various tools.
+        For stock-related queries (price, news, etc.), use the StockAgent tool.
+        For weather-related queries, use the get_weather_forecast tool.
+        Choose the appropriate tool based on the user's request.""",
+        model=llm,
+        tools=[],  # We'll add tools dynamically
+    )
+
+    return agent, {"mcp": False, "a2a": False}
+
+
+async def connect_to_mcp_server(agent: LangGraphAgent) -> bool:
+    """Connect to the MCP server and register tools.
+
+    Args:
+        agent: The LangGraphAgent instance to configure.
+
+    Returns:
+        bool: True if connection was successful, False otherwise.
+    """
+    try:
+        print(f"\nConnecting to MCP server on port {MCP_SERVER_PORT}...")
+        agent.add_mcp_server(
+            {
+                MCP_AGENT_NAME: {
+                    "url": f"http://localhost:{MCP_SERVER_PORT}/sse",
+                    "transport": "sse",
+                    "api_key": "",  # No auth for test server
+                }
+            }
+        )
+        print(f"✅ Successfully connected to MCP server: {MCP_AGENT_NAME}")
+        return True
+    except Exception as e:
+        print(f"⚠️ Failed to connect to MCP server: {e}")
+        print("Continuing without MCP tools...")
+        return False
+
+
+async def connect_to_a2a_server(agent: LangGraphAgent) -> bool:
+    """Connect to the A2A server and register agents.
+
+    Args:
+        agent: The LangGraphAgent instance to configure.
+
+    Returns:
+        bool: True if connection was successful, False otherwise.
+    """
+    try:
+        print(f"\nConnecting to A2A server on port {A2A_SERVER_PORT}...")
+        client_a2a_config = A2AClientConfig(
+            discovery_urls=[f"http://localhost:{A2A_SERVER_PORT}"],
+        )
+
+        print("Discovering A2A agents...")
+        agent_cards = agent.discover_agents(client_a2a_config)
+        print(f"Discovered {len(agent_cards)} A2A agents")
+
+        if not agent_cards:
+            print("⚠️ No A2A agents discovered")
+            return False
+
+        print(f"Registering A2A agent: {agent_cards[0].name}")
+        agent.register_a2a_agents(agent_cards)
+        print("✅ Successfully registered A2A agent")
+        return True
+
+    except Exception as e:
+        print(f"⚠️ Failed to connect to A2A server: {e}")
+        print("Continuing without A2A tools...")
+        return False
+
+
+async def test_mcp_weather_tool(agent: LangGraphAgent) -> None:
+    """Test the MCP weather tool if available.
+
+    Args:
+        agent: The configured LangGraphAgent instance.
+    """
+    print("\n=== Testing MCP Weather Tool ===")
+    weather_query = "What's the weather forecast for tomorrow in London?"
+    print(f"\nQuery: {weather_query}")
+    try:
+        response = await agent.arun(weather_query)
+        print(f"✅ Response: {response.get('output', 'No output')}")
+    except Exception as e:
+        print(f"❌ Error testing MCP weather tool: {e}")
+
+
+async def test_stock_agent(agent: LangGraphAgent) -> None:
+    """Test the A2A Stock Agent if available.
+
+    Args:
+        agent: The configured LangGraphAgent instance.
+    """
+    print("\n=== Testing Stock Agent ===")
+    stock_agent_tool = next((t for t in agent._tools if t.name == "StockAgent"), None)
+
+    if not stock_agent_tool:
+        print("⚠️ StockAgent tool not found in agent's tools")
+        return
+
+    stock_query = "What is the current stock price of AAPL?"
+    print(f"\nQuery: {stock_query}")
+
+    try:
+        tool_input = {"query": "Get current stock price for AAPL"}
+        response = await stock_agent_tool.arun(tool_input)
+        print(f"✅ Response: {response}")
+    except Exception as e:
+        print(f"❌ Error testing Stock Agent: {e}")
+        traceback.print_exc()
+
+
+async def main():
+    """Main function to run the A2A and MCP integration example."""
+    try:
+        # Create and configure agent
+        agent, connected_servers = await create_agent()
+
+        # Connect to servers
+        connected_servers["mcp"] = await connect_to_mcp_server(agent)
+        connected_servers["a2a"] = await connect_to_a2a_server(agent)
+
+        # Verify at least one server is connected
+        if not any(connected_servers.values()):
+            print("❌ Error: Could not connect to any servers. Exiting...")
+            sys.exit(1)
+
+        # Run tests for connected services
+        if connected_servers["mcp"]:
+            await test_mcp_weather_tool(agent)
+        else:
+            print("\nSkipping MCP weather tool tests - MCP server not connected")
+
+        if connected_servers["a2a"]:
+            await test_stock_agent(agent)
+        else:
+            print("\nSkipping Stock Agent tests - A2A server not connected")
+
+    except Exception as e:
+        print(f"\nError: {str(e)}")
+        raise
+
+
+if __name__ == "__main__":
+    asyncio.run(main())