Code Implementation to Building a Model Context Protocol (MCP) Server and Connecting It with Claude Desktop

In this hands-on tutorial, we’ll build an MCP (Model Context Protocol) server that allows Claude Desktop to fetch stock news sentiment and daily top gainers and movers via the AlphaVantage API. Since most LLMs can’t directly access real-time financial data, this solution uses MCP to provide real-time insights.

We’ll expose two tools from our server:

• get_news_sentiment
• get_top_movers

Let’s walk through each step.

Step 1: Setting Up the Environment

We will first set up our environment and start with installing the uv package manager. For Mac or Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh  

For Windows (PowerShell):

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

We will then create a new project directory and initialize it with uv

uv init stockNews
cd stockNews

We can now create and activate a virtual environment. For Mac or Linux:

uv venv
source .venv/bin/activate

For Windows:

uv venv
.venvScriptsactivate

We will now install the required dependencies

uv add mcp httpx python-dotenv 

Step 3: Setting Up the Environment Variables

We will now create a .env file that contains the API key for AlphaVantage. To generate a free API key:

• Go to https://www.alphavantage.co/
• Click on Get free API key button, or use the following url https://www.alphavantage.co/support/#api-key
• Enter your email and other required details. You’ll receive an API key—copy it and keep it safe, as this will be used to authenticate your requests.

Now, create a .env file and add the following line:

ALPHA_VANTAGE_API_KEY = your_api_key

Step 4: Implementing the MCP Server and integrating AlphaVantage

First create a stockNews.py file in the directory that we created and add the following code snippets:

Importing packages and setting up the instance:

We will first import the necessary packages and set up instance to use the API

from typing import Any
import os
import httpx
from mcp.server.fastmcp import FastMCP
from dotenv import load_dotenv


# Load .env variables
load_dotenv()
API_KEY = os.getenv("ALPHA_VANTAGE_API_KEY")

# Initialize FastMCP server
mcp = FastMCP("alpha-finance")

# Constants
BASE_URL = "https://www.alphavantage.co/query"

Helper functions

Next, let’s add our helper functions for querying the data from AlphaVantage.

async def call_alpha_vantage(endpoint: str, params: dict[str, Any]) -> dict[str, Any] | None:
    """Generic async caller to Alpha Vantage."""
    params["apikey"] = API_KEY
    params["function"] = endpoint
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(BASE_URL, params=params, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

Implementing tool execution

The tool execution handler is responsible for executing the logic of each tool.

@mcp.tool()
async def get_news_sentiment(ticker: str) -> str:
    """Get news sentiment data for a stock ticker.

    Args:
        ticker: Stock ticker symbol (e.g., MSFT, AAPL)
    """
    data = await call_alpha_vantage("NEWS_SENTIMENT", {"tickers": ticker.upper()})
    if not data or "feed" not in data:
        return "Couldn't retrieve news sentiment."

    articles = data["feed"][:3]
    result = []
    for item in articles:
        result.append(f"""
 {item['title']}
Summary: {item['summary']}
Source: {item['source']} | Published: {item['time_published']}
""")
    return "n---n".join(result)

@mcp.tool()
async def get_top_movers() -> str:
    """Get top gainers and losers from the stock market.

    No arguments required.
    """
    data = await call_alpha_vantage("TOP_GAINERS_LOSERS", {})
    if not data:
        return "Couldn't retrieve top movers."

    gainers = data.get("top_gainers", [])[:3]
    losers = data.get("top_losers", [])[:3]

    result = "**Top Gainers**n"
    result += "n".join([
        f"{g['ticker']} ({g.get('change_percentage', 'N/A')})"
        for g in gainers
    ])

    result += "nn**Top Losers**n"
    result += "n".join([
        f"{l['ticker']} ({l.get('change_percentage', 'N/A')})"
        for l in losers
    ])

    return result

Running the server

Finally, let’s initialize and run the server:

if __name__ == "__main__":
    mcp.run(transport="stdio")

We will now test our server from an existing MCP host, Claude for Desktop.

Step 5: Testing the server

First, ensure you have Claude for Desktop installed. If not, download and install the latest version from the official source. If you already have it, make sure it’s up to date.

Next, you’ll need to configure Claude to connect with your MCP server. To do this, open the claude_desktop_config.json file located in the Claude directory using any text editor. If the file doesn’t exist, go ahead and create it manually.

For MacOS/Linux:

{
    "mcpServers": {
        "stockNews": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/stockNews",
                "run",
                "stockNews.py"
            ]
        }
    }
}

For Windows:

{
    "mcpServers": {
        "stockNews": {
            "command": "uv",
            "args": [
                "--directory",
                "C:\ABSOLUTE\PATH\TO\PARENT\FOLDER\stockNews",
                "run",
                "stockNews.py"
            ]
        }
    }
}

This configuration lets Claude for Desktop know that:

• There’s an MCP server called “stockNews”.
• It should be launched using the following command:
  uv –directory /ABSOLUTE/PATH/TO/PARENT/FOLDER/stockNews run stockNews.py

Once you’ve added this to your config file, save the file and restart Claude for Desktop to apply the changes.

Test with commands

To confirm that Claude for Desktop has recognized the two tools from your stockNews server, look for the hammer icon in the Claude interface — this icon indicates tool access.

After clicking on the hammer icon, you should see two tools listed:

We can test the server by running the following prompts:

• What is the news sentiment for Apple?
• Who are the top gainers and losers from the stock market?

When you ask Claude a question:

1. The client sends your query to Claude.
2. Claude reviews the available tools (like get_news_sentiment or get_top_movers) and determines which one(s) to use based on your question.
3. The selected tool is executed via the MCP server you configured earlier.
4. The tool returns the results back to Claude.
5. Claude uses those results to craft a natural language response.
6. The final response is shown to you in the chat interface.
   

This seamless flow is what allows Claude to interact with real-time data in a structured and controlled way.

Conclusion:

Our MCP-based stock insights server extends Claude Desktop’s capabilities by enabling real-time financial data retrieval. By integrating the AlphaVantage API with a custom MCP server, users can fetch live news sentiment and track top market movers directly through Claude. This setup empowers users with timely, actionable stock insights—all within a conversational interface—making financial analysis more efficient, contextual, and interactive.

The post Code Implementation to Building a Model Context Protocol (MCP) Server and Connecting It with Claude Desktop appeared first on MarkTechPost.

Source: Read More