feat: Google ADK, LangGraph, OpenAI Agents, PydanticAI examples

Author: andrewginns

.env.example

@@ -0,0 +1,3 @@
+GEMINI_API_KEY=
+OPENAI_API_KEY=
+LOGFIRE_TOKEN=

.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Environment variables
+.env

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -0,0 +1,78 @@
+# Pydantic AI Evaluations with MCP
+
+This repository demonstrates the usage of a simple Model Context Protocol (MCP) server with several frameworks:
+- Google Agent Development Toolkit (ADK)
+- LangGraph Agents
+- OpenAI Agents
+- Pydantic-AI Agents
+
+Tracing is done through Pydantic Logfire.
+
+# Quickstart
+
+`cp .env.example .env`
+- Add `GEMINI_API_KEY` and/or `OPENAI_API_KEY`
+  - Individual scripts can be adjusted to use models from any provider supported by the specifi framework
+    - By default only [basic_mcp_use/oai-agent_mcp.py](basic_mcp_use/oai-agent_mcp.py) requires `OPENAI_API_KEY`
+    - All other scripts require `GEMINI_API_KEY`
+- Add `LOGFIRE_TOKEN` to visualise evaluations in Logfire web ui
+
+## Project Overview
+
+This project aims to teach:
+1. How to use MCP with multiple LLM Agent frameworks
+    - Example MCP tools for adding numbers, getting current time
+2. How to see traces LLM Agents with Logfire
+
+![Logfire UI](docs/images/logfire_ui.png)
+
+
+## Repository Structure
+
+- **basic_mcp_use/** - Contains basic examples of MCP usage:
+  - `adk_mcp.py` - Example of using MCP with Google's Agent Development Kit (ADK)
+  - `langgraph_mcp.py` - Example of using MCP with LangGraph
+  - `oai-agent_mcp.py` - Examoke of using MCP with OpenAI Agents
+  - `pydantic_mcp.py` - Example of using MCP with Pydantic-AI
+
+
+## What is MCP?
+
+The Model Context Protocol allows applications to provide context for LLMs in a standardised way, separating the concerns of providing context from the actual LLM interaction.
+
+Learn more: https://modelcontextprotocol.io/introduction
+
+## Setup Instructions
+
+1. Clone this repository
+2. Install required packages:
+   ```bash
+   uv sync
+   ```
+3. Set up your environment variables in a `.env` file:
+   ```
+   LOGFIRE_TOKEN=your_logfire_token
+   GEMINI_API_KEY=your_gemini_api_key
+   OPENAI_API_KEY=your_openai_api_key
+   ```
+4. Run any of the sample scripts to see a simple MCP server being used via an Agent framework
+- Google Agent Development Toolkit (ADK)
+  - [basic_mcp_use/adk_mcp.py](basic_mcp_use/adk_mcp.py)
+- LangGraph Agents
+  - [basic_mcp_use/langgraph_mcp.py](basic_mcp_use/langgraph_mcp.py)
+- OpenAI Agents
+  - [basic_mcp_use/oai-agent_mcp.py](basic_mcp_use/oai-agent_mcp.py)
+- Pydantic-AI Agents
+  - [basic_mcp_use/pydantic_mcp.py](basic_mcp_use/pydantic_mcp.py)
+
+## About Logfire
+
+[Logfire](https://github.com/pydantic/logfire) is an observability platform from the team behind Pydantic that makes monitoring AI applications straightforward. Features include:
+
+- Simple yet powerful dashboard
+- Python-centric insights, including rich display of Python objects
+- SQL-based querying of your application data
+- OpenTelemetry support for leveraging existing tooling
+- Pydantic integration for analytics on validations
+
+Logfire gives you visibility into how your code is running, which is especially valuable for LLM applications where understanding model behavior is critical.

basic_mcp_use/__init__.py

@@ -0,0 +1 @@
+# Basic MCP usage examples package

basic_mcp_use/adk_mcp.py

@@ -0,0 +1,77 @@
+import asyncio
+import os
+import logfire
+
+from dotenv import load_dotenv
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters
+from google.adk.runners import Runner
+from google.adk.sessions import InMemorySessionService
+from google.genai import types
+
+load_dotenv()
+
+# Set API key for Google AI API from environment variable
+os.environ["GOOGLE_API_KEY"] = os.getenv("GEMINI_API_KEY")
+
+# Configure logging if LOGFIRE_TOKEN is set
+logfire.configure(send_to_logfire="if-token-present")
+logfire.instrument_mcp()
+
+
+async def main(query: str = "Greet Andrew and give him the current time") -> None:
+    """
+    Main function to run the agent
+
+    Args:
+        query (str): The query to run the agent with
+    """
+    # Set up MCP server connection
+    server_params = StdioServerParameters(
+        command="uv",
+        args=["run", "run_server.py", "stdio"],
+    )
+
+    tools, exit_stack = await MCPToolset.from_server(connection_params=server_params)
+    print(f"Connected to MCP server. Found {len(tools)} tools.")
+
+    # Create the agent
+    root_agent = LlmAgent(
+        model="gemini-2.5-pro-preview-03-25",
+        name="mcp_pydantic_assistant",
+        tools=tools,
+    )
+
+    # Set up session
+    session_service = InMemorySessionService()
+    session = session_service.create_session(
+        app_name="mcp_pydantic_app",
+        user_id="aginns",
+    )
+
+    # Create the runner
+    runner = Runner(
+        app_name="mcp_pydantic_app",
+        agent=root_agent,
+        session_service=session_service,
+    )
+
+    # Run the agent with a query
+    content = types.Content(role="user", parts=[types.Part(text=query)])
+
+    print("Running agent...")
+    try:
+        events_async = runner.run_async(
+            session_id=session.id, user_id=session.user_id, new_message=content
+        )
+
+        async for event in events_async:
+            print(f"Event received: {event}")
+    finally:
+        print("Closing MCP server connection...")
+        await exit_stack.aclose()
+        print("Cleanup complete.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

basic_mcp_use/langgraph_mcp.py

@@ -0,0 +1,56 @@
+import asyncio
+import os
+import logfire
+
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_mcp_adapters.tools import load_mcp_tools
+from langgraph.prebuilt import create_react_agent
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+load_dotenv()
+
+# Configure logging if LOGFIRE_TOKEN is set
+logfire.configure(send_to_logfire="if-token-present")
+logfire.instrument_mcp()
+
+
+# Create server parameters for stdio connection
+server = StdioServerParameters(
+    command="uv",
+    args=["run", "run_server.py", "stdio"],
+)
+
+model = ChatGoogleGenerativeAI(
+    model="gemini-2.5-pro-preview-03-25", google_api_key=os.getenv("GEMINI_API_KEY")
+)
+
+
+async def main(query: str = "Greet Andrew and give him the current time") -> None:
+    """
+    Main function to run the agent
+
+    Args:
+        query (str): The query to run the agent with
+    """
+    async with stdio_client(server) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Initialize the connection
+            await session.initialize()
+
+            # Get tools
+            tools = await load_mcp_tools(session)
+
+            # Create agent
+            agent = create_react_agent(model, tools)
+            agent_response = await agent.ainvoke(
+                {
+                    "messages": query,
+                }
+            )
+            print(agent_response["messages"][-1].content)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

basic_mcp_use/oai-agent_mcp.py

@@ -0,0 +1,47 @@
+import os
+import asyncio
+
+import logfire
+from dotenv import load_dotenv
+from agents import Agent, Runner
+from agents.mcp import MCPServerStdio
+
+load_dotenv()
+
+# Configure Logfire
+logfire.configure(send_to_logfire="if-token-present")
+logfire.instrument_mcp()
+logfire.instrument_openai_agents()
+
+
+async def main(query: str = "Greet Andrew and give him the current time") -> None:
+    """
+    Main function to run the agent
+
+    Args:
+        query (str): The query to run the agent with
+    """
+    # Create and use the MCP server in an async context
+    async with MCPServerStdio(
+        params={
+            "command": "uv",
+            "args": ["run", "run_server.py", "stdio"],
+        }
+    ) as server:
+        # Initialize the agent with the server
+        agent = Agent(
+            name="MCP agent",
+            model="o4-mini",
+            mcp_servers=[server],
+        )
+
+        result = await Runner.run(
+            starting_agent=agent,
+            input=query,
+        )
+
+        print(result.final_output)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

basic_mcp_use/pydantic_mcp.py

@@ -0,0 +1,41 @@
+import asyncio
+import os
+
+import logfire
+from dotenv import load_dotenv
+from pydantic_ai import Agent
+from pydantic_ai.mcp import MCPServerStdio
+
+load_dotenv()
+
+# Configure logging to logfire if LOGFIRE_TOKEN is set in environment
+logfire.configure(send_to_logfire="if-token-present")
+logfire.instrument_mcp()
+logfire.instrument_pydantic_ai()
+
+server = MCPServerStdio(
+    command="uv",
+    args=[
+        "run",
+        "run_server.py",
+        "stdio",
+    ],
+)
+agent = Agent("gemini-2.5-pro-preview-03-25", mcp_servers=[server])
+Agent.instrument_all()
+
+
+async def main(query: str = "Greet Andrew and give him the current time") -> None:
+    """
+    Main function to run the agent
+
+    Args:
+        query (str): The query to run the agent with
+    """
+    async with agent.run_mcp_servers():
+        result = await agent.run(query)
+    print(result.output)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())