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

aip_agents/examples/hello_world_langchain_mcp_multi_server.py

@@ -0,0 +1,155 @@
+"""Demo: LangChain agent with allowed_tools whitelist filtering.
+
+Shows how allowed_tools restricts tool access across 3 MCP servers:
+- STDIO: only get_current_time allowed (not generate_uuid or get_weather_forecast)
+- SSE: only get_random_quote allowed (not word_count or get_weather_forecast)
+- HTTP: only get_random_fact allowed (not convert_to_base64 or get_weather_forecast)
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+import logging
+from typing import Any
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.mcp_configs.configs import mcp_tool_whitelisting_demo
+from aip_agents.schema.a2a import A2AStreamEventType
+from aip_agents.utils.logger import logger_manager
+
+
+def _normalize_event_type(raw_value: Any) -> A2AStreamEventType | None:
+    """Convert raw event_type payloads (enum or string) into A2AStreamEventType.
+
+    Args:
+        raw_value: Event type payload emitted by the agent stream (enum or string).
+
+    Returns:
+        Parsed A2AStreamEventType value, or None when the payload is unrecognized.
+    """
+    if isinstance(raw_value, A2AStreamEventType):
+        return raw_value
+    if isinstance(raw_value, str):
+        try:
+            return A2AStreamEventType(raw_value.lower())
+        except ValueError:
+            return None
+    return None
+
+
+def _log_tool_call(event: dict[str, Any], is_allowed: bool) -> bool:
+    """Log tool call events and return True if at least one call existed.
+
+    Args:
+        event: A2A event payload containing tool_call metadata.
+        is_allowed: Whether the current query is expected to hit an allowed tool.
+
+    Returns:
+        True when at least one tool call entry is present; False otherwise.
+    """
+    tool_info = event.get("tool_info") or {}
+    tool_calls = tool_info.get("tool_calls") or []
+    if not tool_calls:
+        print("⚠️ Tool call event received without tool_calls payload")
+        return False
+
+    first_call = tool_calls[0]
+    tool_name = first_call.get("name", "unknown")
+    icon = "⚠️" if not is_allowed else "✅"
+    print(f"{icon} Tool called: {tool_name}")
+    return True
+
+
+async def process_query(agent, query: str, is_allowed: bool = True) -> bool:
+    """Process a single query and report if tools were called.
+
+    Args:
+        agent: The LangChain agent to run.
+        query: The query to process.
+        is_allowed: Whether this query should use allowed tools.
+
+    Returns:
+        True if at least one tool was called while processing the query, False otherwise.
+    """
+    print(f"\nQuery: {query}")
+    tool_called = False
+    final_response = None
+    try:
+        async for event in agent.arun_a2a_stream(query=query):
+            event_type = _normalize_event_type(event.get("event_type"))
+            if event_type is None:
+                print(f"⚠️ Unknown event type payload: {event.get('event_type')!r}")
+                continue
+
+            if event_type is A2AStreamEventType.TOOL_CALL:
+                tool_called = _log_tool_call(event, is_allowed) or tool_called
+                continue
+
+            if event_type is A2AStreamEventType.FINAL_RESPONSE:
+                final_response = event.get("content")
+                break
+    except Exception as e:
+        print(f"❌ Error processing query: {e}")
+        return False
+    if final_response:
+        print(f"🧠 LLM response: {final_response}")
+    if not tool_called:
+        print("✅ No tool called (blocked or LLM answered directly)")
+    return tool_called
+
+
+async def main():
+    """Demo allowed_tools filtering with 3 MCP servers (STDIO, SSE, HTTP)."""
+    logger_manager.set_level(logging.WARNING)
+
+    agent = LangChainAgent(
+        name="allowed_tools_demo",
+        instruction=(
+            "You are a helpful assistant with access to tools from 3 MCP servers.\n"
+            "Use the available tools to answer questions.\n"
+            "Note: Each server has specific tools whitelisted via allowed_tools."
+        ),
+        model=ChatOpenAI(model="gpt-4.1-mini"),
+    )
+    agent.add_mcp_server(mcp_tool_whitelisting_demo)
+
+    all_allowed_queries_called_tools = True
+    any_disallowed_query_called_tools = False
+
+    print("\n=== ALLOWED TOOLS (should work) ===")
+    allowed_queries = [
+        "Get the current time for me",
+        "Tell me an inspirational quote",
+        "Share a fun fact with me",
+    ]
+    for query in allowed_queries:
+        called = await process_query(agent, query, is_allowed=True)
+        all_allowed_queries_called_tools = all_allowed_queries_called_tools and called
+
+    print("\n\n=== DISALLOWED TOOLS (should fail or skip) ===")
+    disallowed_queries = [
+        "Generate a UUID for me",  # Not allowed from STDIO
+        "Get the weather forecast for Jakarta",  # Not allowed from any server
+        "Count words in 'hello world'",  # Not allowed from SSE
+    ]
+    for query in disallowed_queries:
+        called = await process_query(agent, query, is_allowed=False)
+        any_disallowed_query_called_tools = any_disallowed_query_called_tools or called
+
+    print("\n=== SUMMARY: allowed_tools vs disabled_tools behavior ===")
+    if all_allowed_queries_called_tools:
+        print("✅ allowed_tools: All allowed queries called tools as expected.")
+    else:
+        print("❌ allowed_tools: Some allowed queries did not call any tools.")
+
+    if any_disallowed_query_called_tools:
+        print("❌ disabled_tools: Some disallowed queries still called tools.")
+    else:
+        print("✅ disabled_tools: No tools were called for any disallowed queries.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langchain_mcp_sse.py

@@ -0,0 +1,34 @@
+"""Example showing LangChain agent with MCP tools integration using SSE transport.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.mcp_configs.configs import mcp_config_sse
+
+
+async def main():
+    """Demonstrates the LangChainAgent with MCP tools via SSE transport."""
+    langchain_agent = LangChainAgent(
+        name="langchain_mcp_example",
+        instruction=(
+            "You are a helpful assistant that can browse the web. If you are blocked by captcha, try another website."
+        ),
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+    )
+    langchain_agent.add_mcp_server(mcp_config_sse)
+
+    response = await langchain_agent.arun(query="What's the rating of the movie 'The Matrix'? browse it")
+    print(response["output"])
+    print("-" * 50)
+    response = await langchain_agent.arun(query="When is the next solar eclipse?, browse it")
+    print(response["output"])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langchain_mcp_sse_stream.py

@@ -0,0 +1,40 @@
+"""Example showing LangChain agent with MCP tools integration and streaming capabilities using SSE transport.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.mcp_configs.configs import mcp_config_sse
+
+
+async def main():
+    """Demonstrates the LangChainAgent with MCP tools via SSE transport and streaming capabilities."""
+    langchain_agent = LangChainAgent(
+        name="langchain_mcp_stream_example",
+        instruction="""You are a helpful assistant that can browse the web using playwright tools.""",
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+    )
+    langchain_agent.add_mcp_server(mcp_config_sse)
+
+    full_response = ""
+    async for chunk in langchain_agent.arun_stream(
+        query="What are the result of Copa Del Rey Final in 2024/2025 season, browse it.",
+    ):
+        if isinstance(chunk, str):
+            print(chunk, end="", flush=True)
+            full_response += chunk
+        elif isinstance(chunk, dict) and "messages" in chunk:
+            print("\n(Stream finished with final state object)")
+        elif isinstance(chunk, dict):
+            pass
+
+    print(full_response)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langchain_mcp_stdio.py

@@ -0,0 +1,30 @@
+"""Example showing LangChain agent with MCP tools integration using stdio transport.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.mcp_configs.configs import mcp_config_stdio
+
+
+async def main():
+    """Demonstrates the LangChainAgent with MCP tools via stdio transport."""
+    langchain_agent = LangChainAgent(
+        name="langchain_mcp_example",
+        instruction="""You are a helpful assistant that can provide weather forecasts.
+        For weather, specify the day in lowercase (e.g., 'monday').""",
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+    )
+    langchain_agent.add_mcp_server(mcp_config_stdio)
+
+    response = await langchain_agent.arun(query="What's the weather forecast for monday?")
+    print(response["output"])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langchain_mcp_stdio_stream.py

@@ -0,0 +1,41 @@
+"""Example showing LangChain agent with MCP tools integration and streaming capabilities using stdio transport.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.mcp_configs.configs import mcp_config_stdio
+
+
+async def main():
+    """Demonstrates the LangChainAgent with MCP tools via stdio transport and streaming capabilities."""
+    langchain_agent = LangChainAgent(
+        name="langchain_mcp_stream_example",
+        instruction="""You are a helpful assistant that can provide weather forecasts.
+        For weather, specify the day in lowercase (e.g., 'monday').""",
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+    )
+    langchain_agent.add_mcp_server(mcp_config_stdio)
+
+    full_response = ""
+    async for chunk in langchain_agent.arun_stream(
+        query="What's the weather forecast for monday?",
+    ):
+        if isinstance(chunk, str):
+            print(chunk, end="", flush=True)
+            full_response += chunk
+        elif isinstance(chunk, dict) and "messages" in chunk:
+            print("\n(Stream finished with final state object)")
+        elif isinstance(chunk, dict):
+            pass
+
+    print(full_response)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langchain_stream.py

@@ -0,0 +1,36 @@
+"""Minimal LangChain agent example demonstrating streaming capabilities.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+
+
+async def langchain_stream_example():
+    """Demonstrates the LangChainAgent's arun_stream method with async execution."""
+    agent = LangChainAgent(
+        name="LangChainStreamingCalculator",
+        instruction="You are a helpful calculator assistant that can add numbers. "
+        "When asked to add numbers, use the add_numbers tool. "
+        "Explain your steps clearly for streaming demonstration.",
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+        tools=[add_numbers],
+    )
+
+    # Stream the response chunks
+    async for chunk in agent.arun_stream(
+        query="What is the sum of 23 and 47? And then add 10 to that, then add 5 more."
+    ):
+        if isinstance(chunk, str):
+            print(chunk, end="", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(langchain_stream_example())

aip_agents/examples/hello_world_langchain_stream_lm_invoker.py

@@ -0,0 +1,39 @@
+"""Minimal LangChain agent example demonstrating streaming capabilities.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import asyncio
+
+import dotenv
+
+from aip_agents.agent import LangChainAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+
+dotenv.load_dotenv(override=True)
+
+
+async def langchain_stream_example():
+    """Demonstrates the LangChainAgent's arun_stream method with async execution."""
+    agent = LangChainAgent(
+        name="LangChainStreamingCalculator",
+        instruction="You are a helpful calculator assistant that can add numbers. "
+        "When asked to add numbers, use the add_numbers tool. "
+        "Explain your steps clearly for streaming demonstration.",
+        model="openai/gpt-4o",
+        tools=[add_numbers],
+    )
+
+    # Stream the response chunks
+    async for chunk in agent.arun_stream(
+        query="What is the sum of 23 and 47? And then add 10 to that, then add 5 more."
+    ):
+        if isinstance(chunk, str):
+            print(chunk, end="", flush=True)  # Print text chunks as they come in
+        elif isinstance(chunk, dict):
+            print(f"Dict chunk: {chunk}")
+
+
+if __name__ == "__main__":
+    asyncio.run(langchain_stream_example())

aip_agents/examples/hello_world_langflow_agent.py

@@ -0,0 +1,163 @@
+"""Example demonstrating basic Langflow agent usage.
+
+This example shows how to create and use a LangflowAgent for both
+synchronous and asynchronous execution modes.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import asyncio
+import os
+import uuid
+
+from dotenv import load_dotenv
+
+from aip_agents.agent.langflow_agent import LangflowAgent
+from aip_agents.clients.langflow import LangflowApiClient
+
+load_dotenv()
+
+
+async def fetch_flow_id() -> tuple[str, str]:
+    """Fetch available flows and return the first flow ID and name."""
+    print("Fetching available flows...")
+    temp_client = LangflowApiClient(base_url="https://langflow.obrol.id", api_key=os.getenv("LANGFLOW_API_KEY"))
+
+    try:
+        flows = await temp_client.get_all_flows(remove_example_flows=True)
+        print(flows)
+
+        if not flows:
+            print("❌ No flows found!")
+            return "", ""
+
+        print(f"Found {len(flows)} flows:")
+        for i, flow in enumerate(flows[:5]):  # Show first 5 flows
+            flow_name = flow.get("name", "Unnamed")
+            flow_id = flow.get("id", "No ID")
+            print(f"  {i + 1}. {flow_name} (ID: {flow_id})")
+
+        selected_flow = flows[2]
+        flow_id = selected_flow.get("id")
+        flow_name = selected_flow.get("name", "Unknown Flow")
+
+        if not flow_id:
+            print("❌ Selected flow has no ID!")
+            return "", ""
+
+        print(f"✅ Selected flow: {flow_name} (ID: {flow_id})")
+        print("-" * 50)
+        return flow_id, flow_name
+
+    except Exception as e:
+        print(f"❌ Error fetching flows: {e}")
+        print("Falling back to hardcoded flow ID...")
+        return "6dd45ac0-5c05-44c1-9825-66c6c6e516f7", "Fallback Flow"
+
+
+async def create_agent(flow_id: str, flow_name: str) -> LangflowAgent:
+    """Create and configure the Langflow agent.
+
+    Args:
+        flow_id (str): The flow ID to use for the agent.
+        flow_name (str): The name of the flow.
+
+    Returns:
+        LangflowAgent: The configured Langflow agent.
+    """
+    agent = LangflowAgent(
+        name="HelloWorldLangflow",
+        flow_id=flow_id,
+        description=f"A Langflow agent using flow: {flow_name}",
+        base_url="https://langflow.obrol.id",
+    )
+
+    print(f"Created agent: {agent.name}")
+    print(f"Flow ID: {flow_id}")
+    print(f"API Base URL: {agent.api_client.base_url}")
+
+    # Test health check
+    print("Testing health check...")
+    is_healthy = await agent.health_check()
+    print(f"API Health: {'✓ Healthy' if is_healthy else '✗ Unhealthy'}")
+    print("-" * 50)
+
+    return agent
+
+
+async def demonstrate_regular_execution(agent: LangflowAgent) -> None:
+    """Demonstrate regular execution.
+
+    Args:
+        agent (LangflowAgent): The Langflow agent to demonstrate with.
+    """
+    print("Example 1: Regular execution")
+    result1 = await agent.arun("Hello, how are you?")
+    print(f"Message 1: {result1}")
+    print("-" * 50)
+
+
+async def demonstrate_streaming(agent: LangflowAgent) -> None:
+    """Demonstrate streaming execution.
+
+    Args:
+        agent (LangflowAgent): The Langflow agent to demonstrate with.
+    """
+    print("Example 2: Regular streaming")
+    try:
+        print("Streaming response:")
+        async for chunk in agent.arun_stream("Hello, how are you?"):
+            print(chunk)
+        print()  # New line after streaming
+    except Exception as e:
+        print(f"Streaming Error: {e}")
+    print("-" * 50)
+
+
+async def demonstrate_session_management(agent: LangflowAgent) -> None:
+    """Demonstrate session management.
+
+    Args:
+        agent (LangflowAgent): The Langflow agent to demonstrate with.
+    """
+    print("Example 3: Session management")
+    session_id = f"conversation-{uuid.uuid4()}"
+    try:
+        # First message with thread_id
+        result1 = await agent.arun("My name is Alice", configurable={"thread_id": session_id})
+        print(f"Message 1: {result1}")
+
+        # Second message in same thread - should remember context
+        result2 = await agent.arun("What's my name?", configurable={"thread_id": session_id})
+        print(f"Message 2: {result2}")
+
+        # Third message in different thread - should not remember
+        result3 = await agent.arun("What's my name?", configurable={"thread_id": f"new-conversation-{uuid.uuid4()}"})
+        print(f"Message 3 (new thread): {result3}")
+
+    except Exception as e:
+        print(f"Session Error: {e}")
+    print("-" * 50)
+
+
+async def main():
+    """Demonstrate basic Langflow agent usage."""
+    # Fetch flow ID and name
+    flow_id, flow_name = await fetch_flow_id()
+    if not flow_id:
+        return
+
+    # Create agent
+    agent = await create_agent(flow_id, flow_name)
+
+    # Run demonstrations
+    await demonstrate_regular_execution(agent)
+    await demonstrate_streaming(agent)
+    await demonstrate_session_management(agent)
+
+    print("Demo completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aip_agents/examples/hello_world_langgraph.py

@@ -0,0 +1,39 @@
+"""Minimal LangGraph agent example demonstrating asynchronous run."""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.tools.langchain_arithmetic_tools import add_numbers
+
+
+async def langgraph_example():
+    """Demonstrates the LangGraphAgent's arun method."""
+    model = ChatOpenAI(model="gpt-4.1", temperature=0)
+    tools = [add_numbers]
+    agent_name = "LangGraphArithmeticAgent"
+
+    langgraph_agent = LangGraphAgent(
+        name=agent_name,
+        instruction="You are a helpful assistant that can add two numbers using the add_numbers tool.",
+        model=model,
+        tools=tools,
+    )
+
+    query = "What is the sum of 23 and 47? And then add 10 to that, then add 5 more."
+    print(f"--- Agent: {agent_name} ---")
+    print(f"Query: {query}")
+
+    print("\nRunning arun...")
+    response = await langgraph_agent.arun(
+        query=query,
+        configurable={"configurable": {"thread_id": "lgraph_arith_example_arun"}},
+    )
+    print(f"[arun] Final Response: {response['output']}")
+    print("--- End of LangGraph Example ---")
+
+
+if __name__ == "__main__":
+    # OPENAI_API_KEY should be set in the environment.
+    asyncio.run(langgraph_example())

aip_agents/examples/hello_world_langgraph_bosa_twitter.py

@@ -0,0 +1,41 @@
+"""Minimal LangGraph agent with bosa support example demonstrating asynchronous run.
+
+Authors:
+    Saul Sayers (saul.sayers@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.tools import BOSA_AUTOMATED_TOOLS
+
+
+async def langgraph_bosa_example():
+    """Demonstrates the LangGraphAgent's arun method."""
+    model = ChatOpenAI(model="gpt-4.1", temperature=0)
+    agent_name = "BOSAConnectorTwitterAgent"
+
+    langgraph_agent = LangGraphAgent(
+        name=agent_name,
+        instruction="You are a helpful assistant that use BOSA connector to connect with Twitter API.",
+        model=model,
+        tools=BOSA_AUTOMATED_TOOLS["twitter"],
+    )
+
+    query = "Get 3 tweets about the latest Air India Incident"
+    print(f"--- Agent: {agent_name} ---")
+    print(f"Query: {query}")
+
+    print("\nRunning arun...")
+    response = await langgraph_agent.arun(
+        query=query,
+        configurable={"configurable": {"thread_id": "lgraph_arith_example_arun"}},
+    )
+    print(f"[arun] Final Response: {response['output']}")
+    print("--- End of LangGraph Example ---")
+
+
+if __name__ == "__main__":
+    asyncio.run(langgraph_bosa_example())

aip_agents/examples/hello_world_langgraph_mcp_http.py

@@ -0,0 +1,31 @@
+"""Example showing LangGraph agent with MCP tools integration.
+
+Authors:
+    Fachriza Dian Adhiatma (fachriza.d.adhiatma@gdplabs.id)
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+
+from langchain_openai import ChatOpenAI
+
+from aip_agents.agent import LangGraphAgent
+from aip_agents.examples.mcp_configs.configs import mcp_config_http
+
+
+async def main():
+    """Demonstrates the LangGraphAgent with MCP tools via Streamable HTTP transport."""
+    langgraph_agent = LangGraphAgent(
+        name="langgraph_mcp_example",
+        instruction="""You are a helpful assistant that can provide weather forecasts.
+        For weather, specify the day in lowercase (e.g., 'monday').""",
+        model=ChatOpenAI(model="gpt-4.1", temperature=0),
+    )
+    langgraph_agent.add_mcp_server(mcp_config_http)
+
+    response = await langgraph_agent.arun(query="What's the weather forecast for monday?")
+    print(f"Response: {response['output']}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())