How to Build and Test AI Agents That Call External APIs

What Is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI agents discover and call external tools and data sources. Before MCP, every agent framework had its own way of defining tools OpenAI function calling, LangChain tools, custom REST wrappers. Each required its own integration code. MCP standardises the interface so a tool server built once can be used by any MCP-compatible agent, regardless of the underlying model or framework.

The architecture is straightforward. A tool server exposes a set of functions over HTTP or stdio. An agent connects to the server, discovers the available tools, and calls them as part of its reasoning loop. The agent does not need to know how the tools are implemented it only needs the server URL and the tool descriptions.

The Localhost Problem for AI Agent Development

When you build a tool server locally and run an agent on the same machine, everything works. The agent calls http://localhost:8000/mcp and the server responds. The problem starts the moment the agent runs somewhere other than your laptop.

The solution is to give your local tool server a public HTTPS URL using a Localtonet HTTP tunnel. The tunnel runs on your laptop alongside the server, forwards traffic from the public relay address to your local port, and the agent connects to the relay URL instead of localhost. Nothing else changes.

Build a Local MCP Tool Server

The fastest way to build an MCP tool server in Python is with FastMCP, which handles the protocol details and lets you focus on writing the actual tools as plain Python functions.

pip install fastmcp httpx

# server.py
import httpx
from fastmcp import FastMCP

mcp = FastMCP("My Tool Server")

@mcp.tool()
async def get_weather(latitude: float, longitude: float) -> dict:
    """Get current weather for a location using coordinates."""
    url = "https://api.open-meteo.com/v1/forecast"
    params = {
        "latitude": latitude,
        "longitude": longitude,
        "current": "temperature_2m,wind_speed_10m,weather_code",
        "temperature_unit": "celsius"
    }
    async with httpx.AsyncClient() as client:
        response = await client.get(url, params=params)
        data = response.json()
        return data["current"]

@mcp.tool()
async def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    """Convert an amount from one currency to another using live exchange rates."""
    url = f"https://open.er-api.com/v6/latest/{from_currency.upper()}"
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        data = response.json()
        if data["result"] != "success":
            return {"error": "Could not fetch exchange rates"}
        rate = data["rates"].get(to_currency.upper())
        if not rate:
            return {"error": f"Unknown currency: {to_currency}"}
        return {
            "from": from_currency.upper(),
            "to": to_currency.upper(),
            "amount": amount,
            "converted": round(amount * rate, 4),
            "rate": rate
        }

if __name__ == "__main__":
    mcp.run(transport="http", host="127.0.0.1", port=8000)

python server.py

The server listens at http://127.0.0.1:8000/mcp. Verify it is running by fetching the tool list:

curl http://127.0.0.1:8000/mcp/tools/list

Give the Tool Server a Public URL with Localtonet

With the server running on 127.0.0.1:8000, create an HTTP tunnel in Localtonet to give it a public HTTPS endpoint.

localtonet --authtoken <YOUR_TOKEN>

curl https://abc123.localto.net/mcp/tools/list

If it returns your tool list, the server is reachable from anywhere on the internet. This URL is what you give to agents, teammates, and cloud platforms.

Connect a LangChain Agent to the Tool Server

LangChain's MCP adapter converts tool server endpoints into LangChain-compatible tool objects. Point the adapter at your Localtonet tunnel URL and the agent can call your tools from anywhere; your laptop, a cloud runner, a teammate's machine.

pip install langchain-mcp-adapters langgraph langchain-openai

# agent.py
import asyncio
import os
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Replace with your actual Localtonet tunnel URL
MCP_SERVER_URL = "https://abc123.localto.net/mcp"

async def run_agent(query: str):
    client = MultiServerMCPClient({
        "my-tools": {
            "url": MCP_SERVER_URL,
            "transport": "http",
        }
    })

    tools = await client.get_tools()
    model = ChatOpenAI(model="gpt-4o", api_key=os.environ["OPENAI_API_KEY"])
    agent = create_react_agent(model, tools)

    response = await agent.ainvoke({
        "messages": [{"role": "user", "content": query}]
    })

    return response["messages"][-1].content

if __name__ == "__main__":
    result = asyncio.run(
        run_agent("What is the weather in Istanbul right now? Also convert 100 USD to EUR.")
    )
    print(result)

OPENAI_API_KEY=your_key python agent.py

The agent receives the query, discovers the available tools from the MCP server over HTTPS, calls get_weather and convert_currency as needed, and returns a natural language answer. All tool calls go through the Localtonet tunnel to your local server.

Testing Strategies for AI Agent Tool Servers

# Call a specific tool directly via the MCP HTTP endpoint
curl -X POST https://abc123.localto.net/mcp/tools/call \
  -H "Content-Type: application/json" \
  -d '{
    "name": "get_weather",
    "arguments": {"latitude": 41.01, "longitude": 28.95}
  }'

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

@mcp.tool()
async def get_weather(latitude: float, longitude: float) -> dict:
    """Get current weather for a location using coordinates."""
    logger.info(f"get_weather called: lat={latitude}, lon={longitude}")
    # ... tool logic
    logger.info(f"get_weather result: {result}")
    return result

// claude_desktop_config.json
{
  "mcpServers": {
    "my-local-tools": {
      "url": "https://abc123.localto.net/mcp",
      "transport": "http"
    }
  }
}

Frequently Asked Questions