ai-garage

AI Agent using Model Context Protocol (MCP)

Introduction

This project implements an AI agent using the Model Context Protocol (MCP) architecture, providing a flexible interface for LLM-powered interactions with various data sources.

It consists of an MCP Client with a command-line interface that can connect to different MCP Servers, including a Financial Data Server leveraging the Financial Modeling Prep (FMP) API to help answer users’ questions.

What is MCP?

The Model Context Protocol (MCP) is a specification for communication between large language models (LLMs) and external tools/services. Developed by Anthropic, MCP addresses several critical challenges in AI agent development:

Why MCP Matters

• Standardized Tool Calling: MCP provides a consistent interface for LLMs to interact with tools, reducing implementation complexity.
• Language/Framework Agnostic: Works across different programming languages and frameworks, enabling interoperability.
• Separation of Concerns: Cleanly separates the LLM’s reasoning capabilities from the execution of tools.
• Enhanced Security: By establishing boundaries between the LLM and tool execution environments, MCP improves security and control.
• Simplified Development: Developers can focus on creating the tool functionality without worrying about LLM integration details.

Project Architecture

This project implements the MCP architecture in the following manner:

sequenceDiagram
    actor User
    participant Client as MCP Client
    participant Server as MCP Server
    participant API as Financial API Server
    participant LLM as LLM (Azure/OpenAI/Ollama)
    
    %% Initialization
    User->>Client: Start client with server argument
    Client->>Server: Connect (stdio transport)
    Server-->>Client: Connection established
    Client->>Server: list_tools() request
    Server-->>Client: Return available tools
    Client-->>User: Display available tools
    
    %% User query flow
    User->>Client: Submit query
    Client->>LLM: Send query with available tools
    
    %% Tool calling flow with alt section for repeated tool calls
    LLM-->>Client: Response with tool calls
    
    loop while response contains tool calls
        Client->>Server: call_tool(tool_name, args)
        Server->>API: Request financial data
        API-->>Server: Return financial data
        Server-->>Client: Return tool execution results
        Client->>LLM: Send updated context with tool results
        LLM-->>Client: Generate new response
    end

    Client-->>User: Display final response
    
    %% Conversation continues
    User->>Client: Submit new query or 'quit'
    
    %% Cleanup on exit
    User->>Client: 'quit'
    Client->>Server: Close connection
    Client-->>User: Exit application

Components

• MCP Client: Command-line interface that handles user queries, connects to MCP servers, and processes LLM responses.
• MCP Servers: Specialized servers that expose domain-specific tools via the MCP protocol.
  • Currently implemented: Financial Data Server using Financial Modeling Prep API
• LLM Integration: Supports multiple LLM providers (Azure OpenAI, OpenAI, Ollama) for processing queries and tool calls.

Implemented Features

MCP Client

• Beautiful command-line interface for user interactions
• Connects to the financial data MCP server
• Supports multiple LLM providers (Azure OpenAI, OpenAI, Ollama)

Financial Data MCP Server

Provides tools for accessing financial data via the Financial Modeling Prep API:

• Company profiles
• Balance sheets
• Cash flow statements
• Key financial metrics
• Financial ratios
• Real-time stock quotes

Setup & Usage

Prerequisites

Before using this AI agent, ensure you have the following:

• Python 3.8 or higher
• uv package installer, recommended for Python project management (Reference)
• Access to one of the supported LLM providers:
  • Azure OpenAI [Reference Video]
  • OpenAI
  • Ollama (with a model that supports tool calling)

Installation

1. Clone the repository & get into the project directory

    git clone https://github.com/tezansahu/ai-garage.git
    cd ai-garage/mcp-agent
   

2. Create and activate a virtual environment using uv:

    uv venv
    # On Windows
    .\.venv\Scripts\activate
    # On macOS/Linux
    source .venv/bin/activate
   

3. Install all dependencies

    uv sync
   

4. Set up environment variables by creating .env files as follows:
   • In mcp_client/.env:

       # For Azure OpenAI
       AZURE_API_KEY=your_azure_api_key
       AZURE_API_BASE=your_azure_endpoint
       AZURE_API_VERSION=your_api_version
       AZURE_API_DEPLOYMENT_NAME=your_deployment_name
     
       # For OpenAI
       OPENAI_API_KEY=your_openai_api_key
     

   • In financial_data_mcp_server/.env:

       FINANCIAL_MODELING_PREP_API_KEY=your_fmp_api_key
     

Usage

• cd mcp_client & start the MCP client, specifying the path to the MCP server script:

    python mcp_client.py --server financial_data
  

  • If you wish to run using a different model provider, use the syntax:

      python mcp_client.py --server financial_data --llm-provider ollama --model qwen2.5:7b
    

• Once connected, you’ll see a list of available tools.
• Type your queries about financial data, for example:
  • “What is the current stock price of Microsoft?”
  • “Show me Apple’s balance sheet for the last 3 years.”
  • “Compare financial ratios between Tesla and Ford.”
• Type quit to exit the chat loop.

[Optional] Feel free to comment out line number 534 (logger.info(f"Processing request of type {type(req).__name__}")) in .venv/Lib/site-packages/mcp/server/lowlevel/server.py

LLM Provider Configurations

The client supports different LLM providers:

• Azure OpenAI (default)
• OpenAI
• Ollama (for local models)

This site is open source. Improve this page.