CFOCoder

Building Your First MCP Server: A Journey from API to AI Assistant

How I built a production-ready MCP server for Mexican economic data and what I learned along the way

As someone who works at the intersection of data science and finance, I’m always looking for ways to make economic data more accessible. When I discovered the Model Context Protocol (MCP), I saw an opportunity to bridge the gap between financial APIs and AI assistants. This post chronicles my journey building a comprehensive MCP server for the Bank of Mexico’s (Banxico) API, and the lessons learned that you can apply to any API.

What is MCP and Why Should You Care?

The Model Context Protocol (MCP) is a game-changer for AI workflows. Instead of manually copying data from APIs into Claude or other AI assistants, MCP lets your AI directly query live data sources. Imagine asking Claude “What’s Mexico’s current inflation rate?” and getting real-time data from the central bank, not outdated training data.

For financial professionals and data scientists, this opens up incredible possibilities:

  • Real-time market analysis with live data feeds
  • Economic research with direct access to central bank APIs
  • Automated reporting that pulls fresh data on demand
  • Cross-dataset analysis combining multiple financial sources

The Challenge: Mexican Economic Data

I chose the Banxico (Bank of Mexico) SIE API as my first MCP project because:

  1. Rich dataset: Exchange rates, inflation, unemployment, interest rates
  2. Financial relevance: Critical data for Latin American market analysis
  3. API complexity: Real authentication, rate limits, and data formatting challenges
  4. Documentation gaps: Perfect for learning API integration patterns

The goal was ambitious: create a production-ready MCP server that any developer could use, with comprehensive documentation and multiple distribution methods.

Phase 1: API Archaeology

Before writing any code, I spent significant time understanding the Banxico API structure. This detective work proved crucial later.

API Exploration Process

# First, test basic connectivity
curl "https://www.banxico.org.mx/SieAPIRest/service/v1/series/SF63528/datos/oportuno?token=YOUR_TOKEN"

# Analyze the response structure
curl "https://www.banxico.org.mx/SieAPIRest/service/v1/series/SF63528" | jq .

# Test different endpoints to understand patterns
curl "https://www.banxico.org.mx/SieAPIRest/service/v1/series/SF63528/datos/2024-01-01/2024-01-31"

Key Discoveries

  1. Authentication: Token-based via query parameter
  2. Data Structure: Nested JSON with bmx.series[].datos[] hierarchy
  3. Date Format: DD/MM/YYYY in responses (not ISO format!)
  4. Rate Limits: Reasonable limits for development use
  5. Error Handling: HTTP status codes + JSON error messages

💡 Lesson Learned: Spend 20% of your time understanding the API before coding. It saves 80% of debugging time later.

Phase 2: Architecture Decisions

Choosing FastMCP

I evaluated several MCP frameworks and chose FastMCP for its:

  • Decorator-based tools: Simple @mcp.tool() syntax
  • Automatic type inference: Parameters become tool schemas automatically
  • Built-in server: No manual protocol handling
  • Great documentation: Clear examples and patterns
@mcp.tool()
async def get_latest_usd_mxn_rate() -> str:
    """Get the most recent USD/MXN exchange rate from Banxico."""
    # Implementation here

Handling Dependencies

One challenge with MCP servers is dependency management. Users need FastMCP and httpx, but may not have them installed. My solution:

try:
    from fastmcp import FastMCP
except ImportError:
    print("Installing required dependencies...")
    import subprocess
    import sys
    subprocess.check_call([sys.executable, "-m", "pip", "install", "fastmcp", "httpx"])
    from fastmcp import FastMCP

This auto-installs dependencies, making the server “just work” for end users.

Phase 3: Building Robust Tools

The HTTP Request Foundation

Every API integration needs robust HTTP handling. Here’s my pattern:

async def make_banxico_request(endpoint: str, token: str) -> dict[str, Any] | None:
    """Make a request to the Banxico API with comprehensive error handling."""
    url = f"{BANXICO_API_BASE}/{endpoint}"
    headers = {"User-Agent": "banxico-mcp/1.0"}
    params = {"token": token}
    
    try:
        async with httpx.AsyncClient() as client:
            response = await client.get(url, headers=headers, params=params, timeout=30.0)
            response.raise_for_status()
            return response.json()
    except httpx.HTTPError as e:
        logger.error(f"HTTP error occurred: {e}")
        return None
    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return None

Key principles:

  • Timeout handling: 30-second timeout prevents hanging
  • Proper error logging: Helps users debug issues
  • Return None on failure: Lets calling code handle errors gracefully

Smart Data Formatting

Raw API responses are often not human-readable. I created specialized formatters:

def format_inflation_data(data: dict[str, Any]) -> str:
    """Format inflation data with percentage symbols and clear structure."""
    # ... implementation
    for dato in datos[-display_count:]:
        fecha = dato.get("fecha", "Unknown date")
        valor = dato.get("dato", "N/A")
        # Add percentage symbol for inflation data
        if valor != "N/A":
            try:
                valor_num = float(valor)
                valor = f"{valor_num}%"
            except (ValueError, TypeError):
                pass
        result.append(f"  {fecha}: {valor}")

Design decisions:

  • Domain-specific formatting: Percentages for rates, commas for large numbers
  • Graceful degradation: Handle missing or invalid data
  • Visual hierarchy: Indentation and symbols for readability
  • Emoji indicators: 📊 for inflation, 💰 for financial data, 👥 for labor data

Tool Design Philosophy

Each tool follows a consistent pattern:

  1. Check authentication first
  2. Make API request with error handling
  3. Apply user parameters (limits, filters)
  4. Format for human consumption
  5. Return actionable error messages
@mcp.tool()
async def get_inflation_data(inflation_type: str = "monthly", limit: Optional[int] = 12) -> str:
    """
    Get inflation data from Banxico.
    
    Args:
        inflation_type: Type of inflation data ('monthly', 'accumulated', 'annual')
        limit: Maximum number of recent data points (default: 12)
    """
    if not BANXICO_TOKEN:
        return "Error: BANXICO_API_TOKEN environment variable not set. Please configure your API token."
    
    series_map = {
        "monthly": "SP30577",
        "accumulated": "SP30579", 
        "annual": "SP30578"
    }
    
    if inflation_type not in series_map:
        return f"Invalid inflation type: {inflation_type}. Available: {list(series_map.keys())}"
    
    # ... rest of implementation

Phase 4: The Distribution Challenge

Here’s where things got interesting. How do you distribute an MCP server so users get automatic updates?

The uvx Revolution

I discovered that uvx can run Python packages directly from GitHub:

{
  "mcpServers": {
    "banxico": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/cfocoder/banxico_mcp",
        "banxico-mcp-server"
      ],
      "env": {
        "BANXICO_API_TOKEN": "your_token_here"
      }
    }
  }
}

This is revolutionary for MCP servers:

  • ✅ Automatic updates: Users get new features when I push to GitHub
  • ✅ Zero installation: No manual pip installs or environment setup
  • ✅ Dependency isolation: uvx handles everything in isolated environments
  • ✅ Cross-platform: Works identically on Windows, macOS, and Linux

Supporting Multiple Installation Methods

Not everyone wants auto-updates, so I provided alternatives:

Method 1: Auto-updates (Recommended)

# No installation needed, just configure MCP client

Method 2: Single file download

curl -O https://raw.githubusercontent.com/cfocoder/banxico_mcp/main/banxico_mcp_server.py
# Then point MCP client to local file

Method 3: Traditional clone

git clone https://github.com/cfocoder/banxico_mcp.git
pip install fastmcp httpx
python banxico_mcp_server.py

Phase 5: Documentation as Code

I learned that MCP servers live or die by their documentation. Users need to configure multiple clients (Claude Desktop, Gemini CLI, Continue.dev), each with different config formats.

The Documentation Strategy

  1. Main README: Comprehensive but scannable
  2. Individual client guides: Copy-paste ready configurations
  3. Extension guide: For developers adding new endpoints
  4. Troubleshooting section: Real issues users face

Example Configuration Template

For each MCP client, I created identical structure:

# Example Configuration: [Client Name]

## Method 1: Auto-Updates (Recommended)
[Working configuration]

## Method 2: Local File
[Alternative configuration]

## Setup Instructions
[Step-by-step process]

## Testing
[How to verify it works]

## Troubleshooting
[Common client-specific issues]

Pro tip: Always include both auto-update and manual options. Some users want bleeding-edge features, others want stability.

The Results: A Production MCP Server

After several iterations, the Banxico MCP server now provides:

Financial Data Coverage

  • Exchange Rates: Real-time USD/MXN with historical data
  • Inflation Metrics: Monthly, annual, and accumulated inflation
  • Interest Rates: CETES rates and central bank rates
  • Labor Market: Unemployment statistics
  • Monetary Policy: Reserve assets and financial indicators

Developer Experience

  • 9 comprehensive tools with intuitive parameters
  • Auto-updating distribution via uvx
  • Multi-client support: Claude Desktop, Gemini CLI, Continue.dev, VS Code Cline
  • Comprehensive documentation with working examples
  • Extension guide for adding new endpoints

User Experience

Natural language queries like:

  • “What’s Mexico’s current inflation rate?”
  • “Show me USD/MXN trends for the last month”
  • “How has unemployment changed this year?”

Lessons Learned and Best Practices

1. API-First Development

Spend significant time understanding the API before coding. Document endpoint patterns, authentication methods, rate limits, and response structures.

2. Error Messages Matter

Users will encounter authentication issues, network problems, and invalid parameters. Write error messages that tell them exactly what to do:

# Bad
return "Error: Failed to get data"

# Good  
return "Error: BANXICO_API_TOKEN environment variable not set. Get your token from https://www.banxico.org.mx/SieAPIRest/service/v1/token"

3. Documentation is Your Product

For MCP servers, documentation quality determines adoption. Provide:

  • Working configuration examples for every major client
  • Copy-paste ready code snippets
  • Troubleshooting sections based on real user issues
  • Extension guides for developers

4. Distribution Strategy Matters

uvx + GitHub is a game-changer for MCP servers. Auto-updating distribution means users always have the latest features without manual updates.

5. Think in User Workflows

Design tools around how users actually work:

  • Sensible defaults (last 30 days, recent data)
  • Flexible parameters (limits, date ranges, data types)
  • Domain-specific formatting (percentages, currency symbols)

Technical Architecture Highlights

Environment-Based Configuration

BANXICO_TOKEN = os.getenv("BANXICO_API_TOKEN")

Never hardcode secrets. Environment variables make deployment flexible and secure.

Async HTTP with Proper Timeouts

async with httpx.AsyncClient() as client:
    response = await client.get(url, timeout=30.0)

Async operations prevent blocking, timeouts prevent hanging.

Type Hints for Better DX

async def get_historical_data(limit: Optional[int] = 30) -> str:

Type hints improve IDE support and tool schema generation.

Structured Logging

logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
logger = logging.getLogger(__name__)

Proper logging helps users and developers debug issues.

Future Enhancements

The server is production-ready but has room for growth:

  1. More Economic Indicators: GDP, trade balance, fiscal data
  2. Data Visualization: Generate charts for time series data
  3. Alert System: Notify on significant rate changes
  4. Multi-Language Support: Spanish documentation for Mexican users
  5. Caching Layer: Reduce API calls for frequently requested data

Call to Action: Build Your Own MCP Server

The patterns I’ve developed for the Banxico server are applicable to any REST API. Whether you’re working with:

  • Financial APIs: Yahoo Finance, Alpha Vantage, FRED
  • Government Data: Census, BLS, Treasury APIs
  • Business Intelligence: Salesforce, HubSpot, analytics platforms
  • Scientific Data: Weather, environmental, research databases

The MCP ecosystem needs more high-quality servers. The tools and documentation patterns are established – now it’s about connecting valuable APIs to AI assistants.

Getting Started Resources

Conclusion

Building the Banxico MCP server taught me that successful API integrations require more than just making HTTP requests. They need thoughtful tool design, comprehensive error handling, flexible distribution methods, and documentation that serves both end users and developers.

The Mexican financial data that was previously locked behind API complexity is now accessible through natural language queries. Users can ask Claude about inflation trends or exchange rate patterns and get real-time, accurate data.

More importantly, the patterns and practices developed for this server are reusable. The next MCP server I build (already planning one for Federal Reserve economic data) will leverage these same architectural decisions and documentation patterns.

The future of data access is conversational, and MCP servers are the bridge between structured APIs and natural language interfaces. If you’re working with valuable datasets that could benefit the AI community, I encourage you to build your own MCP server. The tools are mature, the patterns are established, and the impact on user experience is transformational.

What APIs would you like to see wrapped as MCP servers? Let me know in the comments or reach out on GitHub. I’m always interested in collaborating on financial and economic data integrations.

Technical Appendix

Quick Start for Developers

Want to try the Banxico MCP server? Here’s the fastest path:

  1. Get a Banxico API token: Register here
  2. Configure Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):
{
  "mcpServers": {
    "banxico": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/cfocoder/banxico_mcp",
        "banxico-mcp-server"
      ],
      "env": {
        "BANXICO_API_TOKEN": "your_token_here"
      }
    }
  }
}
  1. Restart Claude Desktop and ask: “What’s the current USD to MXN exchange rate?”

Performance Characteristics

Based on production usage:

  • Cold start time: ~2-3 seconds (uvx dependency resolution)
  • Warm response time: ~500-800ms (API latency dependent)
  • Memory footprint: ~15-20MB (FastMCP + httpx + server code)
  • Error rate: <1% (primarily network/API issues)

Monitoring and Observability

For production deployments, consider:

  • Structured logging with correlation IDs
  • Metrics collection on response times and error rates
  • Health checks for API connectivity
  • Token expiration monitoring and alerting

The server includes basic logging, but production deployments may want enhanced observability.

This post represents my personal experience building MCP servers and shouldn’t be considered official guidance from any organization. Always follow your organization’s security and development policies when integrating external APIs.

Print Friendly, PDF & Email
Share
August 17, 2025 by AI

Hector Sanchez

Hector Sanchez is a Public Accountant with over 30 years of experience as accountant and financial analyst, and with diplomas in Corporate Finance and Data Science.

You may also like...

Leave a Reply

Your email address will not be published. Required fields are marked *