mcp_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx",
            args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)

import os
from dotenv import load_dotenv
from mcp import StdioServerParameters, stdio_client
from strands import Agent
from strands.models.litellm import LiteLLMModel
from strands.tools.mcp import MCPClient

load_dotenv()

nebius_api_key = os.getenv("NEBIUS_API_KEY")
if not nebius_api_key:
    raise ValueError("NEBIUS_API_KEY environment variable is required")

model = LiteLLMModel(
    client_args={"api_key": nebius_api_key},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
)

# Set up MCP client to connect to AWS documentation server
mcp_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx",
            args=["awslabs.aws-documentation-mcp-server@latest"]
        )
    )
)

# Create agent with AWS documentation tools
with mcp_client:
    aws_tools = mcp_client.list_tools_sync()
    print(f"Successfully loaded {len(aws_tools)} tools from the MCP server.")
    
    agent = Agent(
        model=model,
        tools=aws_tools,
        system_prompt=(
            "You are an expert on Amazon Web Services. "
            "Use the provided tools to answer questions about AWS services "
            "based on the official documentation. Always provide accurate, "
            "up-to-date information from the AWS docs."
        ),
    )
    
    # Query the agent
    user_query = "What is the maximum invocation payload size for AWS Lambda?"
    print("\n--- Querying AWS Documentation ---")
    print(f"User Query: {user_query}\n")
    
    response = agent(user_query)
    
    print("--- Agent Response ---")
    print(response)

Successfully loaded 3 tools from the MCP server.

--- Querying AWS Documentation ---
User Query: What is the maximum invocation payload size for AWS Lambda?

--- Agent Response ---
According to the AWS Lambda documentation, the maximum invocation payload 
size (request and response) is 6 MB for synchronous invocations and 256 KB 
for asynchronous invocations.

import os
from dotenv import load_dotenv
from mcp import StdioServerParameters, stdio_client
from strands import Agent
from strands.models.litellm import LiteLLMModel
from strands.tools.mcp import MCPClient

load_dotenv()

# Validate required environment variables
required_vars = ["NEBIUS_API_KEY", "EXA_API_KEY"]
missing_vars = [var for var in required_vars if not os.getenv(var)]
if missing_vars:
    raise ValueError(f"Missing required variables: {', '.join(missing_vars)}")

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324",
)

# MCP Client 1: Web search
web_search_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="npx",
            args=["-y", "@modelcontextprotocol/server-exa"],
            env={"EXA_API_KEY": os.getenv("EXA_API_KEY")}
        )
    )
)

# MCP Client 2: Accommodation booking
accommodation_client = MCPClient(
    lambda: stdio_client(
        StdioServerParameters(
            command="uvx",
            args=["mcp-server-accommodation"]
        )
    )
)

# Combine tools from multiple servers
with web_search_client, accommodation_client:
    web_tools = web_search_client.list_tools_sync()
    accommodation_tools = accommodation_client.list_tools_sync()
    
    all_tools = web_tools + accommodation_tools
    print(f"Loaded {len(all_tools)} tools from {2} MCP servers")
    
    agent = Agent(
        model=model,
        tools=all_tools,
        system_prompt="You are a helpful travel assistant with access to web search and accommodation booking tools.",
    )
    
    # Example queries
    queries = [
        "What's the fastest way to get to Barcelona from London?",
        "What listings are available in Cape Town for 2 people for 3 nights?"
    ]
    
    for query in queries:
        print(f"\n--- Query: {query} ---")
        response = agent(query)
        print(f"Response: {response}\n")

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

try:
    # Validate configuration
    if not os.getenv("NEBIUS_API_KEY"):
        raise ValueError("NEBIUS_API_KEY is required")
    
    # Set up MCP client
    with mcp_client:
        tools = mcp_client.list_tools_sync()
        logger.info(f"Loaded {len(tools)} tools")
        
        # Create and use agent
        agent = Agent(model=model, tools=tools)
        response = agent(query)
        
except ConnectionError as e:
    logger.error(f"Failed to connect to MCP server: {e}")
except ValueError as e:
    logger.error(f"Configuration error: {e}")
except Exception as e:
    logger.error(f"Unexpected error: {e}")