Building AI Agents with Google ADK and MCP: A Complete Guide

from fastmcp import FastMCP
import httpx

# Create MCP server
mcp = FastMCP("Currency Exchange Server")

@mcp.tool()
async def get_exchange_rate(
    from_currency: str,
    to_currency: str,
    amount: float = 1.0
) -> dict:
    """
    Get current exchange rate between two currencies.
    
    Args:
        from_currency: Source currency code (e.g., USD)
        to_currency: Target currency code (e.g., EUR)
        amount: Amount to convert (default: 1.0)
    """
    # Call Frankfurter API for real exchange rates
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.frankfurter.app/latest",
            params={
                "from": from_currency,
                "to": to_currency,
                "amount": amount
            }
        )
        data = response.json()
        
        return {
            "from": from_currency,
            "to": to_currency,
            "amount": amount,
            "converted": data["rates"][to_currency],
            "rate": data["rates"][to_currency] / amount
        }

# Run the server
if __name__ == "__main__":
    mcp.run()

from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.models.lite_llm import LiteLlm

# Define a custom tool
def get_weather(city: str) -> dict:
    """
    Get weather information for a city.
    
    Args:
        city: Name of the city
    """
    # Simulated weather data
    return {
        "city": city,
        "temperature": "22°C",
        "condition": "Sunny",
        "humidity": "65%"
    }

# Create the agent
weather_agent = LlmAgent(
    name="WeatherBot",
    description="A helpful weather assistant",
    model=LiteLlm(model_id="gemini/gemini-2.0-flash-exp"),
    instructions="""
    You are a friendly weather assistant. When users ask about weather,
    use the get_weather tool to fetch information and present it in a
    helpful, conversational manner.
    """,
    tools=[FunctionTool(get_weather)]
)

# Export for ADK CLI
root_agent = weather_agent

from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import MCPToolset, StdioServerParameters
from google.adk.models.lite_llm import LiteLlm
import os

# Create MCP toolset connecting to YouTube search server
mcp_tools = MCPToolset.from_server(
    connection_params=StdioServerParameters(
        command="npx",
        args=["-y", "mcp-youtube-search"],
        env={
            "YOUTUBE_API_KEY": os.getenv("YOUTUBE_API_KEY")
        }
    )
)

# Create agent with MCP tools
youtube_agent = LlmAgent(
    name="YouTubeAssistant",
    description="Search and find YouTube videos",
    model=LiteLlm(model_id="gemini/gemini-2.0-flash-exp"),
    instructions="""
    You help users find relevant YouTube videos. Use the search tool
    to find videos based on user queries, and present the results
    in an organized, helpful manner.
    """,
    tools=[mcp_tools]
)

root_agent = youtube_agent

from google.adk.a2a import AgentCard, AgentSkill

agent_card = AgentCard(
    name="DataAnalyzer",
    url="http://localhost:8001",
    version="1.0.0",
    skills=[
        AgentSkill(
            id="analyze_data",
            name="Data Analysis",
            description="Analyze datasets and provide insights",
            examples=["Analyze sales data", "Find trends in user behavior"]
        )
    ]
)

from google.adk.agents import LlmAgent
from google.adk.tools.agent_tool import RemoteA2aAgent
from google.adk.models.lite_llm import LiteLlm

# Define specialized agents
flight_agent = RemoteA2aAgent(
    name="FlightAgent",
    url="http://localhost:8001"
)

hotel_agent = RemoteA2aAgent(
    name="HotelAgent", 
    url="http://localhost:8002"
)

# Create orchestrator agent
travel_planner = LlmAgent(
    name="TravelOrchestrator",
    description="Coordinates travel planning",
    model=LiteLlm(model_id="gemini/gemini-2.0-flash-exp"),
    instructions="""
    You are a travel planning coordinator. Use the FlightAgent to find
    flights and HotelAgent to book hotels. Coordinate between them to
    create complete travel plans.
    """,
    tools=[flight_agent, hotel_agent]
)

root_agent = travel_planner

from google.adk.agents import LlmAgent
from google.adk.tools.agent_tool import RemoteA2aAgent
from google.adk.tools.mcp_tool import MCPToolset, StdioServerParameters
from google.adk.models.lite_llm import LiteLlm

# Define remote A2A agents
social_profiling_agent = RemoteA2aAgent(
    name="SocialProfiler",
    url="http://localhost:8001"
)

event_planning_agent = RemoteA2aAgent(
    name="EventPlanner",
    url="http://localhost:8002"
)

# MCP tool for platform interaction
platform_mcp_tools = MCPToolset.from_server(
    connection_params=StdioServerParameters(
        command="node",
        args=["instavibe-mcp-server.js"]
    )
)

# Create orchestrator
orchestrator = LlmAgent(
    name="InstaVibeOrchestrator",
    description="Coordinates social activity planning",
    model=LiteLlm(model_id="gemini/gemini-2.5-pro-exp"),
    instructions="""
    You orchestrate a multi-agent system for social planning:
    
    1. Use SocialProfiler to analyze user interests and connections
    2. Use EventPlanner to find suitable activities
    3. Use platform MCP tools to interact with InstaVibe API
    
    Coordinate these agents to create personalized social experiences.
    """,
    tools=[
        social_profiling_agent,
        event_planning_agent,
        platform_mcp_tools
    ]
)

root_agent = orchestrator

orchestrator = LlmAgent(
    name="SmartOrchestrator",
    instructions="""
    Orchestrate agents with complex logic:
    
    WHILE task not complete:
        IF needs_research:
            Use research_agent
        ELIF needs_analysis:
            Use data_analyst_agent
        ELIF needs_execution:
            Use action_agent
        
        Evaluate result
        Adjust strategy if needed
    
    Return comprehensive solution
    """,
    tools=[research_agent, analyst_agent, action_agent]
)

instructions="""
You are a data analyst assistant.

PROCESS:
1. Understand the user's analytical question
2. Determine what data is needed
3. Use available tools to gather data
4. Analyze the results
5. Present findings clearly with visualizations when helpful

RULES:
- Always validate data before analysis
- If data is insufficient, ask for clarification
- Provide context with your numbers
- Use tools when you need current information
"""

# First: Single function tool
agent = LlmAgent(
    name="Calculator",
    tools=[FunctionTool(add), FunctionTool(multiply)]
)

# Then: MCP integration
agent = LlmAgent(
    name="WebSearcher",
    tools=[MCPToolset.from_server(...)]
)

# Finally: Multi-agent orchestration
orchestrator = LlmAgent(
    name="Orchestrator",
    tools=[
        RemoteA2aAgent(name="Agent1", url="..."),
        RemoteA2aAgent(name="Agent2", url="..."),
        MCPToolset.from_server(...)
    ]
)

# Use ADK's built-in UI for testing
adk web

# Monitor tool execution
# Enable verbose logging
# Test each component independently