LangChain

This section contains implementation using LangGraph.

Getting Started

Prerequisites

• Python 3.11 - 3.13

• Poetry (for dependency management)

• OpenAI API key

Setup

1. Clone the repository:

   git clone https://github.com/GDP-ADMIN/gen-ai-examples.git 

2. Navigate to the Quickstart Directory

   cd gen-ai-examples/examples/aip-agent-quickstart

3. Install dependencies:

   poetry install

4. Setup OpenAPI key

   export OPENAI_API_KEY='your-openai-api-key-here'

Basic implementation

We can use LangChainAgent to utilize LangChain's framework using our Agent Interface.

from gllm_agents.agent.langchain_agent import LangChainAgent
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import CALCULATOR_AGENT_INSTRUCTION
from aip_agent_quickstart.tools import langchain_add_numbers

agent = LangChainAgent(
    name="LangChainArithmeticAgent",
    instruction=CALCULATOR_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
    tools=[langchain_add_numbers],
)

response = agent.run(query="What is the sum of 23 and 47? And then add 10 to that, then add 5 more.")
print(response["output"])

Running the Agent

You can run the following to test running the agent;

poetry run python hello_world_langchain.py

You should see the following output:

The sum of 23 and 47 is 70. Adding 10 gives 80, and adding 5 more gives a final result of 85.

Multi-agent

We provide multi-agent capabilities out of the box for LangChain agents. The following example showcases:

1. How to define multiple specialized agents (WeatherAgent, MathAgent).

2. How to set up a CoordinatorAgent that can delegate to these specialized agents.

3. How the CoordinatorAgent uses dynamically created tools to call sub-agents.

4. How the CoordinatorAgent can delegate tasks to the appropriate sub-agents.

from gllm_agents.agent.langchain_agent import LangChainAgent
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import (
    COORDINATOR_MULTI_AGENT_INSTRUCTION,
    MATH_AGENT_INSTRUCTION,
    WEATHER_AGENT_INSTRUCTION,
)
from aip_agent_quickstart.tools import langchain_add_numbers, langchain_weather_tool

weather_agent = LangChainAgent(
    name="WeatherAgent",
    instruction=WEATHER_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
    tools=[langchain_weather_tool],
)

math_agent = LangChainAgent(
    name="MathAgent",
    instruction=MATH_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
    tools=[langchain_add_numbers],
)

coordinator_agent = LangChainAgent(
    name="CoordinatorAgent",
    instruction=COORDINATOR_MULTI_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
    agents=[weather_agent, math_agent],
)

response = coordinator_agent.run(query="What is the weather in Tokyo and what is 5 + 7?")
print(response.get("output"))

Running the Agent

You can run the following to test the capability:

poetry run python hello_world_multi_agent_langchain.py

You should see the following output:

[INFO] Coordinator asynchronously delegating to agent 'WeatherAgent' with query: What is the weather in Tokyo?
[INFO] Coordinator asynchronously delegating to agent 'MathAgent' with query: What is 5 + 7?

[INFO] Agent 'WeatherAgent' asynchronously responded: The weather in Tokyo is currently 25°C with clear skies.
[INFO] Agent 'MathAgent' asynchronously responded: 5 + 7 is 12.

Response: The weather in Tokyo is currently 25°C with clear skies. Also, 5 + 7 is 12.

MCP

We have the capability to connect to MCP client for LangChain agents.

stdio

Start the MCP server

In a new terminal window, execute this

poetry run python aip_agent_quickstart/mcp_servers/mcp_server_stdio.py

Upon success, the window remains open without displaying any output.

Run agent using MCP-based tools

The following is how we can configure our LangChain Agent to run using MCP-based tools.

from gllm_agents.agent.langchain_agent import LangChainAgent
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import DEFAULT_AGENT_INSTRUCTION
from aip_agent_quickstart.mcp_configs.configs import mcp_config_stdio

langchain_agent = LangChainAgent(
    name="langchain_mcp_example",
    instruction=DEFAULT_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
)
langchain_agent.add_mcp_server(mcp_config_stdio)

response = langchain_agent.run(query="What's the weather forecast for monday?")
print(f"Response: {response.get('output')}")

To test the agent, in the current terminal window run the following command:

poetry run python hello_world_langchain_mcp_stdio.py

You should see the following output:

Attempting to connect to MCP server 'weather_tools'...
Successfully connected to MCP server 'weather_tools'...
Agent 'langchain_mcp_example': Retrieved 1 tools from MCP server.

Response: The weather forecast for Monday is sunny, with temperatures ranging between 28°C and 32°C.

SSE

Start the MCP server

In a new terminal window, execute this

poetry run python aip_agent_quickstart/mcp_servers/mcp_server_sse.py

Upon success, you should see the following output

INFO:     Started server process [71744]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Run agent using MCP-based tools

The following is how we can configure our LangChain Agent to run using MCP-based tools.

from gllm_agents.agent.langchain_agent import LangChainAgent
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import DEFAULT_AGENT_INSTRUCTION
from aip_agent_quickstart.mcp_configs.configs import mcp_config_sse

langchain_agent = LangChainAgent(
    name="langchain_mcp_example",
    instruction=DEFAULT_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
)
langchain_agent.add_mcp_server(mcp_config_sse)

response = langchain_agent.run(query="What's the weather forecast for monday?")
print(f"Response: {response.get('output')}")

To test the agent, in the current terminal window run the following command:

poetry run python hello_world_langchain_mcp_sse.py

You should see the following output:

Attempting to connect to MCP server 'weather_tools'...
Successfully connected to MCP server 'weather_tools'...
Agent 'langchain_mcp_example': Retrieved 1 tools from MCP server.

Response: The weather forecast for Monday is sunny, with temperatures ranging between 28°C and 32°C.

A2A (Agent-to-Agent)

LangChain agents can act as A2A agents and can also coordinate agents hosted on remote A2A servers.

Deploy Agent as A2A server

To initiate the specialized Weather Agent server, follow one of these instruction(s):

Python (script)

Start the Server

To start the Weather Agent server using Python and Poetry, first we need to open a new terminal window. Then export OpenAI API key:

export OPENAI_API_KEY='your-openai-api-key-here'
export framework='langchain'

Then run this command from your project's root directory:

poetry run python aip_agent_quickstart/agents/weather_agent/server.py

By default, the server will start and listen on http://localhost:8001

You can customize the host and port using the --host and --port command-line options.

This script performs the following key actions:

1. Imports weather_tool.

2. Builds a Agent Card with metadata.

3. Wraps a LangChain agent as an A2A app.

Podman

Setup

Install Podman in your CLI.

Start the Server

To run the Weather Agent server using Podman Compose, first we need to open a new terminal window. Then export OpenAI API key:

export OPENAI_API_KEY='your-openai-api-key-here'

Then run the command below:

framework=langchain podman-compose up weather_agent --build

Notes

1. The server is typically available at http://localhost:8001 (or as configured in your docker-compose.yml).

   1. Please make sure that any other program is not using port 8001. If it is in use, please use the command sh ./kill_port 8001 (This only works for Linux/WSL/macOS).

2. Controlling Service Startup:

   1. To run a different specific service: podman-compose up <other_service_name>

   2. To launch all services defined in docker-compose.yml: podman-compose up

3. To run in the background (detached mode), use: podman-compose up -d.

This method uses Podman Compose to start the Weather Agent server and any other services defined in the docker-compose.yml file.

Call Agents via the A2A client

Once your Weather Agent server runs, then attempt one of the following approaches:

Non-streaming

The following is how we can call A2A agent with non-streaming mode

from gllm_agents.agent.langchain_agent import LangChainAgent
from gllm_agents.agent.types import A2AClientConfig
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import DEFAULT_AGENT_INSTRUCTION

agent = LangChainAgent(
    name="AssistantAgentLangChain",
    instruction=DEFAULT_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
)

client_a2a_config = A2AClientConfig(discovery_urls=["http://localhost:8001"])
agent_cards = agent.discover_agents(client_a2a_config)
response = agent.send_to_agent(agent_cards[0], message="What is the weather in Jakarta?")
print(response.get("content", str(response)))

Test the script by running

poetry run python hello_world_a2a_langchain_client.py

These scripts will do the following:

1. Instantiate LangChainAgent

2. Discover the Weather Agent at its URL.

3. Send What is the weather in Jakarta City?

4. Receive the full response when it's ready.

Expected Output:

Discovered agents (1 Agents): 
1. WeatherAgent
...
The weather in Jakarta City is currently 32°C, partly cloudy, and there is high humidity

Streaming

The following is how we can call A2A agent with streaming mode

import asyncio

from gllm_agents.agent.langchain_agent import LangChainAgent
from gllm_agents.agent.types import A2AClientConfig
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import DEFAULT_AGENT_INSTRUCTION

agent = LangChainAgent(
    name="AssistantAgentLangChain",
    instruction=DEFAULT_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", streaming=True),
)

client_a2a_config = A2AClientConfig(discovery_urls=["http://localhost:8001"])
agent_cards = agent.discover_agents(client_a2a_config)

async for chunk in agent.astream_to_agent(agent_card=agent_cards[0], message="What is the weather in Jakarta?"):
    print(chunk.get("content", ""))

Test the script by running

poetry run python hello_world_a2a_langchain_client_streaming.py

These scripts will do the following:

1. Instantiate LangChainAgent

2. Discover the Weather Agent at its URL.

3. Send What is the weather in Jakarta City?

4. Receive the full response when it's ready.

Expected Output:

Discovered agents (1 Agents): 
1. WeatherAgent
...
The weather in Jakarta City is currently 32°C, partly cloudy, and there is high humidity

Direct Agent orchestration

The following is how we can involve the A2A Agent directly into the local agent's workflow.

from gllm_agents.agent.langchain_agent import LangChainAgent
from gllm_agents.agent.types import A2AClientConfig
from langchain_openai import ChatOpenAI

from aip_agent_quickstart.config import DEFAULT_AGENT_INSTRUCTION

agent = LangChainAgent(
    name="AssistantAgentLangChain",
    instruction=DEFAULT_AGENT_INSTRUCTION,
    model=ChatOpenAI(model="gpt-4.1", temperature=0),
)

client_a2a_config = A2AClientConfig(discovery_urls=["http://localhost:8001"])
agent_cards = agent.discover_agents(client_a2a_config)
agent.register_a2a_agents(agent_cards)
response = agent.run(query="What is the weather in Jakarta?")
print(response["output"])

Test the script by running

poetry run python hello_world_a2a_langchain_client_agent.py

The script will do the following:

1. Instantiate LangChainAgent

2. Discover & register the Weather Agent as a tool

3. Ask What is the weather in Jakarta City? through the assistant.

Here's what happens when you run the client:

Successfully discovered agent 'WeatherAgent' at http://localhost:8001
...
Registered 1 A2A agents: 
1. WeatherAgent
...
The weather in Jakarta City is currently 32°C, partly cloudy, and quite humid. If you need more details or a forecast for the next few days, feel free to ask!

Stopping the A2A Server

Python (script)

If the server is running in the foreground (as it will with the command above), press Ctrl+C in the terminal where it's running.

Podman

Run the following command to stop the A2A server:

podman-compose down