Introduction

Model Context Protocol (MCP) is a protocol that allows large language models (LLMs) and various computational services (called “servers” in MCP) to interact in a common environment, enabling the creation of powerful AI-driven agents. In simpler terms, MCP helps orchestrate how different tools, data sources, and models communicate. By abstracting away many low-level details and providing a straightforward server-based integration approach, MCP makes it easier for developers to build robust, multi-step AI applications—including sophisticated agents that can perform tasks such as SQL query generation, execution, and result summarization.

In this guide, we explore how to build a Text2SQL Agent using the mcp-agent repository. Our agent will take a natural language query as input, write SQL on the fly, execute it against a Postgres database, and return the results. The underlying technologies (OpenAI, Anthropic, or others) can be flexibly swapped in and out thanks to MCP’s server-based architecture.

Building a Text2SQL Agent with MCP

Let’s walk through the main code required to set up our Text2SQL Agent, connect it to a Postgres database, and use either OpenAI or Anthropic as the underlying LLM.

Install the server

Clone this repo. Build the postgres server using the command below:

docker build -t mcp/postgres -f src/postgres/Dockerfile .

If you are using the server using npx, you need not build it.

Code Overview

Below is a simplified version of the Python script that configures and runs our agent. It uses the mcp_agent library and attaches a Postgres server for querying data. Note that it also configures an LLM (OpenAI in this case). You can place this code in a file (e.g., main.py), then run it.

Below is the same example code broken down into smaller segments, each explained in turn. Feel free to adapt or merge these segments as needed.

1. Imports and Setup

from mcp_agent.app import MCPApp
from mcp_agent.agents.agent import Agent
from mcp_agent.workflows.llm.augmented_llm import RequestParams
from mcp_agent.workflows.llm.llm_selector import ModelPreferences
from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM

2. Initializing the MCP Application

We create an instance of MCPApp, giving it a descriptive name. This app will manage configuration, logging, and orchestrate our agents and servers.

app = MCPApp(name="mcp_text2sql_agent")

3. Setting Up the Text2SQL Agent

async def main():
async with app.run() as agent_app:
logger = agent_app.logger
context = agent_app.context

# Create a Text2SQL agent, specifying we want to connect to the "postgres" server
text2sql_agent = Agent(
name="Text2SqlAgent",
instruction="""You are an agent with access to the database and you are given a query.
You need to execute the query and return the results.""",
server_names=["postgres"]
)

# Open a session with the agent
async with text2sql_agent:
logger.info("text2sql: Connected to server, calling list_tools...")

# Optionally list available tools:
# tools_list = await text2sql_agent.list_tools()
# logger.info("Tools available:", data=tools_list.model_dump())

# Attach the OpenAI-based LLM to our agent
llm = await text2sql_agent.attach_llm(OpenAIAugmentedLLM)

# Ask a question that requires generating and executing SQL
result = await llm.generate_str(
message="Which countries bring in the highest total revenue from orders?",
request_params=RequestParams(
modelPreferences=ModelPreferences(
temperature=0.05
),
),
)
logger.info(f"Result: {result}")

Results

We tested the Text2SQL agent on the Northwind database. We asked the following questions, which ranged from easy to complex in terms of difficulty:

• Which products generate the highest total revenue?
• Which customers place the most orders?
• Which product categories have the highest total sales?
• Which employee has processed the greatest number of orders?
• Which countries bring in the highest total revenue from orders?
• Within each category, which product has the highest overall sales?
• How have total sales trended by month or year?
• Which orders applied the largest discounts, and how does that affect revenue?
• What is the average shipping duration for each shipper?
• Which products have not been ordered in the last year (or a specific date range)?

Here is the analysis of how each question performed:

Discussion

This agent used a straightforward Text2SQL agent without advanced features such as schema injection, dbt modeling, or data transformations. We found:

• Schema injection: This was a test using a simple text2sql agent without any advanced techniques like dbt modelling, schema injection etc. Can we implement them to make the agent more accurate and faster? The answer is yes. But can we use MCP to implement them? The answer is probably yes, but it is not straightforward and easy as per the current implementation.
• Extensibility: Within the implementation of the agent, the MCP server setup is super-easy. All it takes is to clone the postgres server and attach the connection string of the database.
• Minimal Setup and Reuse: The MCP server implementation itself is done once and can be reused for multiple agents/applications, and even remotely as well.
• Comparison to Other Frameworks: The agent implementation in Langgraph is very complex from the software engineering standpoint. MCP implementation stands out in this regard. You can abstract away the sql server in a separate codebase, and thereby focusing on the agent logic in your codebase.
• MCP Features: The agent implementation in MCP is also super-easy. It comes with a lot of features out of the box like logging, metrics, tracing, etc. It also has the ability to get human in the loop when the agent requires clarification.
• Future Integrations: MCP agent itself can be exposed as a server and can be a very powerful tool. - What I like about MCP is its integration with Claude desktop app and VSCode etc. As time progresses, we will hopefully see more integrations, and that is exciting. Think of integrating sql server with slack. Would there be any need of separate BI tools/workflows in the future? Only time can tell.

Conclusion

Agents build using MCP are super-easy to understand and modify. Their simplicity is a great advantage from a software engineering perspective since you can easily weave in the business logic.

AI Agents are as such more of a software engineering problem than an AI problem. To that end, MCP provides a very flexible design patterns to build systems with LLMs, and tools. MCP is very amenable to building agents and would definitely love to use it more.

But, can MCP be used as a drop-in replacement for Langgraph? I think the answer is yes, but I think a better design is to combine them. Langgraph can have the ability to build DAG to define execution paths. MCP agents can be used in the lower level implementation of the nodes in the DAG.