DEV Community: Sushyam Nagallapati

Building Your First AI Agent with MCP: A Step-by-Step Guide

Sushyam Nagallapati — Sun, 05 Jul 2026 23:23:46 +0000

If you've heard about the Model Context Protocol (MCP) but aren't sure how to build something with it, this guide is for you.

In my previous article, I explained what MCP is and why it matters. If you haven't read it yet, I recommend starting there first.

Understanding the concepts is one thing. Building an AI agent that actually uses MCP is another.

In this guide, you'll build a simple AI agent that communicates with an MCP server, uses external tools, and returns useful responses. More importantly, you'll understand why each component exists and how they work together.

By the end, you'll have a solid foundation that you can extend into more advanced AI applications.

What You'll Build

Imagine asking an AI assistant:

"What's the weather in Toronto today?"

Instead of guessing the answer, the AI contacts a weather tool, retrieves real information, and responds naturally.

That entire interaction is made possible through the Model Context Protocol.

Our simple AI agent will:

Receive a user's question
Decide whether a tool is required
Call an MCP server
Receive structured data
Generate a final response

Although we'll use a weather example, this same architecture is used for:

AI coding assistants
Customer support agents
Document search applications
Database assistants
Internal company chatbots

Prerequisites

Before getting started, make sure you have:

Python 3.11 or later
Claude Desktop
Visual Studio Code (recommended)
Basic Python knowledge

We'll also use the official MCP Python SDK.

Understanding the Architecture

Before writing code, it's helpful to understand how requests flow through an MCP application.

┌──────────┐
│   User   │
└────┬─────┘
     │
     ▼
┌───────────────┐
│ Claude Desktop│
└────┬──────────┘
     │
     ▼
┌───────────────┐
│  MCP Client   │
└────┬──────────┘
     │
     ▼
┌───────────────┐
│  MCP Server   │
└────┬──────────┘
     │
     ▼
┌───────────────┐
│ Custom Tool   │
└────┬──────────┘
     │
     ▼
 Structured Data
     │
     ▼
 Claude generates
 natural response
     │
     ▼
     User

Each component has a specific responsibility.

Component	Responsibility
User	Asks a question
Claude	Understands the request
MCP Client	Sends tool requests
MCP Server	Exposes available tools
Tool	Performs the requested task
Claude	Generates the final response

Step 1: Create a Project

Create a new project folder.

mkdir weather-agent
cd weather-agent

Create a virtual environment.

python -m venv .venv

Activate it.

Windows

.venv\Scripts\activate

macOS/Linux

source .venv/bin/activate

Install the MCP SDK.

pip install mcp

Step 2: Build Your First MCP Server

Every MCP server exposes one or more tools.

A tool is simply a function that AI models can call whenever they need information or need to perform an action.

Examples include:

Weather lookup
Calculator
File reader
SQL database query
Email sender

Let's build a weather tool.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Weather Server")

@mcp.tool()
def get_weather(city: str):
    return f"The weather in {city} is sunny and 24°C."

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

Although this example returns hardcoded data, the same structure works with real APIs.

Step 3: Understanding the Code

Let's break down what happened.

mcp = FastMCP("Weather Server")

Creates an MCP server.

@mcp.tool()

Registers a Python function as an MCP tool.

def get_weather(city: str):

Defines the tool that Claude can call.

mcp.run()

Starts the MCP server.

Once the server is running, Claude automatically discovers every registered tool.

You never explicitly tell Claude when to use the tool.

Claude decides that based on the user's request.

Step 4: Connect Claude Desktop

Claude Desktop needs to know where your MCP server is running.

Update your MCP configuration.

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": [
        "/path/to/weather_server.py"
      ]
    }
  }
}

Restart Claude Desktop.

If everything is configured correctly, Claude will automatically discover your new weather tool.

Step 5: Test Your Agent

Now ask Claude:

What's the weather in Toronto today?

Behind the scenes, this workflow takes place.

User asks question
        │
        ▼
Claude understands request
        │
        ▼
Needs external data?
        │
       Yes
        │
        ▼
Calls Weather Tool
        │
        ▼
Receives result
        │
        ▼
Writes natural response
        │
        ▼
Returns answer

Notice something important.

Claude isn't writing Python code.

It's deciding when a tool should be used.

That decision-making process is what makes AI agents so powerful.

Why MCP Matters

Without MCP:

Question

↓

LLM guesses

↓

Possible hallucination

With MCP:

Question

↓

LLM calls tool

↓

Gets real data

↓

Returns reliable answer

Instead of relying only on its training data, the model can interact with external systems whenever necessary.

Expanding Your Agent

Once you've built one tool, adding more is straightforward.

For example:

Calculator

calculate(expression)

File Reader

read_file(filename)

SQL Database

query_database(sql_query)

Email Sender

send_email()

Document Search

search_documents(question)

The AI chooses which tool to call based on the user's request.

Common Beginner Mistakes

1. Expecting every prompt to use a tool

AI models only call tools when they determine a tool is necessary.

2. Returning unstructured text

Whenever possible, return structured data such as JSON.

Structured responses are easier for language models to understand.

3. Building large tools

A single tool should perform one clear task.

Smaller tools are easier to maintain and easier for AI models to use correctly.

4. Ignoring error handling

Validate inputs and return meaningful error messages.

Reliable tools lead to reliable AI applications.

Next Steps

Now that you've built a simple MCP server, try extending it with real-world integrations.

Some ideas include:

Connect a real weather API
Search local documents
Query a PostgreSQL database
Build a GitHub assistant
Connect Google Calendar
Build a file management assistant
Create a multi-agent system with LangGraph

Each project builds on the same MCP foundation you've learned here.

Final Thoughts

Building your first MCP server is more than just another Python project.

It introduces a practical pattern for connecting language models with real tools and real data.

Instead of expecting an AI model to know everything, you allow it to discover and use specialized tools whenever they're needed.

As AI applications continue to evolve, protocols like MCP will become an important part of modern software development. Learning these concepts now will prepare you to build assistants that can search documents, interact with APIs, query databases, automate workflows, and solve real-world problems.

Start with one tool.

Then add another.

Before long, you'll have an AI agent capable of handling tasks that go far beyond simple conversation.

Thanks for Reading

If you found this guide helpful, consider following me for more articles on AI Engineering, MCP, LangGraph, RAG, FastAPI, and Full Stack development.

🔗 LinkedIn: https://www.linkedin.com/in/sushyamnagallapati/

Happy building!

Model Context Protocol (MCP) Servers Explained: A Complete Beginner's Guide

Sushyam Nagallapati — Fri, 03 Jul 2026 13:59:05 +0000

Artificial Intelligence has become incredibly capable.

It can write code, explain complex concepts, summarize documents, and even help debug applications.

But there is one important limitation.

An AI model doesn't automatically know how to access your GitHub repositories, query your database, read files from your computer, or interact with your internal applications.

Traditionally, developers solved this by building custom integrations for every AI application and every service they wanted to connect.

This approach quickly became difficult to maintain.

That's where the Model Context Protocol (MCP) comes in.

Think of MCP as a universal connector for AI applications. Instead of creating separate integrations for every tool, developers can expose their applications through an MCP server, allowing any compatible AI client to use them.

In this guide, we'll explore what MCP is, why it was created, how it works, and why it's becoming one of the most important standards in the AI ecosystem.

What is Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open standard that allows AI assistants to communicate with external tools, APIs, databases, file systems, and applications using a common protocol.

Instead of every AI application creating its own integration with every service, MCP defines one standard way for them to communicate.

Simply put,

MCP allows AI models to use external tools in a secure and standardized way.

Why Was MCP Created?

Imagine four different AI assistants:

ChatGPT
Claude
Gemini
Cursor

Now imagine you want all of them to access:

GitHub
Slack
PostgreSQL
Jira
Google Drive

Without MCP, every AI application needs its own integration.

ChatGPT  → GitHub

Claude   → GitHub

Gemini   → GitHub

Cursor   → GitHub

Now multiply this by dozens of services.

Maintaining all of these integrations quickly becomes expensive and time consuming.

With MCP, the architecture becomes much simpler.

flowchart TD

AI["AI Clients<br/>ChatGPT • Claude • Cursor"]

MCP["MCP Server"]

GitHub["GitHub"]
Slack["Slack"]
DB["Database"]
Drive["Google Drive"]

AI --> MCP
MCP --> GitHub
MCP --> Slack
MCP --> DB
MCP --> Drive

One integration can now serve many AI clients.

What Is an MCP Server?

An MCP server is a lightweight application that exposes tools, resources, and prompts to AI clients.

It acts as a bridge between the AI model and external systems.

Instead of allowing the AI to directly communicate with your database or APIs, the AI sends requests to the MCP server.

The server performs the requested operation and returns the results in a structured format.

This makes integrations easier to build and easier to secure.

MCP Architecture

An MCP ecosystem usually consists of three parts.

flowchart LR

User --> Client["AI Client"]

Client --> Server["MCP Server"]

Server --> APIs["External APIs"]
Server --> Files["File System"]
Server --> DB["Database"]
Server --> Apps["Business Applications"]

Each component has a specific responsibility.

Component	Responsibility
AI Client	Sends requests and displays responses
MCP Server	Executes tools and retrieves data
External Services	Databases, APIs, files, cloud services

Core Components of an MCP Server

An MCP server usually exposes three different capabilities.

1. Tools

Tools are functions that the AI can execute.

Examples include:

Search GitHub repositories
Read a file
Send an email
Query a database
Restart a service

Example:

search_customer()

create_invoice()

get_weather(city)

The AI decides when a tool should be called.

2. Resources

Resources provide information that the AI can read.

Examples include:

Documentation
Configuration files
Database records
PDFs
Markdown files

Resources are primarily used for reading information.

3. Prompts

Prompt templates can also be shared through an MCP server.

Examples include:

Generate release notes
Create a bug report
Summarize a meeting
Review a pull request

Instead of writing the same prompt repeatedly, developers can expose reusable templates.

MCP Client vs MCP Server

This is one of the most common points of confusion.

MCP Client

The client is the AI application.

Examples include:

Claude Desktop
Cursor
VS Code extensions
ChatGPT desktop applications

Its responsibilities include:

Connecting to MCP servers
Discovering available tools
Calling tools
Displaying responses

MCP Server

The server provides the actual functionality.

It:

Connects to databases
Calls APIs
Reads files
Executes functions
Returns structured results

A good way to think about it is:

The client asks.

The server performs the work.

How Communication Works

Suppose you ask your AI assistant:

"Show me all open GitHub issues."

Here's what happens behind the scenes.

sequenceDiagram

participant User
participant AI
participant MCP
participant GitHub

User->>AI: Show open issues

AI->>MCP: Call GitHub tool

MCP->>GitHub: Fetch issues

GitHub-->>MCP: Issue list

MCP-->>AI: Structured response

AI-->>User: Display results

The AI never talks directly to GitHub.

Everything goes through the MCP server.

A Simple Real World Example

Imagine you're building an internal company assistant.

Employees ask:

"How many orders were placed today?"

Instead of the AI connecting directly to the production database, it calls an MCP tool.

get_daily_orders()

The MCP server safely queries the database and returns something like:

{
  "orders": 428
}

The AI then responds:

There have been 428 orders placed today.

The AI never sees your database credentials.

The server handles everything securely.

Building Your First MCP Server

Most MCP servers follow a simple workflow.

flowchart TD

A[Install MCP SDK]

B[Create Server]

C[Register Tools]

D[Connect External APIs]

E[Run Server]

F[Connect AI Client]

A --> B --> C --> D --> E --> F

Typical tools might include:

read_file()
search_documents()
execute_sql()
get_weather()
send_email()

Once the server starts, compatible AI clients can automatically discover these tools.

Popular MCP Servers

Many companies and open source projects already provide MCP servers.

Some popular examples include:

GitHub
Docker
PostgreSQL
SQLite
Google Drive
Slack
Notion
Jira
Kubernetes
AWS
Azure
Stripe

Organizations can also build custom MCP servers for their own internal applications.

Benefits of MCP

MCP offers several advantages for developers.

One standard integration for multiple AI clients
Easier maintenance
Better security through controlled tool execution
Vendor independence
Structured communication
Faster development
Reusable integrations
Better scalability

Instead of building the same integration multiple times, developers only need to build it once.

Limitations

Although MCP is powerful, it's still an evolving standard.

Some current limitations include:

Requires MCP-compatible AI clients
Server availability affects tool availability
Permissions must be designed carefully
Performance depends on external services
Some legacy systems still require custom adapters

These challenges are expected to improve as adoption continues to grow.

Why MCP Matters

The software industry has seen standards transform the way developers build applications.

REST standardized web APIs.

Docker standardized application packaging.

USB standardized hardware connectivity.

MCP is aiming to do something similar for AI applications.

Instead of every AI platform inventing its own integration system, developers now have a common protocol that works across multiple clients.

As AI agents become more capable, standards like MCP will play an increasingly important role in building secure, scalable, and interoperable AI systems.

Final Thoughts

Model Context Protocol is much more than another AI buzzword.

It solves a real problem by providing a standard way for AI applications to interact with external tools and services.

Whether you're building AI-powered applications, internal assistants, developer tools, or enterprise software, understanding MCP will become an increasingly valuable skill.

If you're starting your AI development journey, learning how to build an MCP server is an excellent next step.

Key Takeaways

MCP is an open standard for connecting AI applications with external tools.
An MCP server acts as a secure bridge between AI clients and external systems.
AI clients discover and execute tools exposed by MCP servers.
MCP reduces the need for custom integrations.
The protocol is quickly becoming a foundational technology for modern AI applications.

Let's Connect

Thanks for taking the time to read this article.

I'm passionate about learning and building in AI, Machine Learning, DevOps, Cloud, and Software Engineering. I regularly share what I learn through technical blogs and hands-on projects.

If you're interested in these topics or just want to connect with fellow developers, I'd love to connect on LinkedIn.

🔗 LinkedIn: https://www.linkedin.com/in/sushyamnagallapati/

Thanks again, and happy coding!

💬 This is my first article on DEV. If you have any suggestions, spot anything I could improve, or want to share your experience with MCP, I'd love to hear your thoughts in the comments.