Complete MCP Developer Guide: Agents, Servers & Tools

Explore the fundamentals of agents, their historical context, and the evolution from the react prompting paradigm. See how an agent selects and executes tools, with a quick tool calling demo.

Define agents as language model-driven systems that reason, act, and adapt in real time, using tools and observing function results to fulfill user queries.

Explore the react prompting paradigm that uses a language model to simulate chain-of-thought and tool usage, guiding reasoning, execution, and validation for tasks like building a to-do list in code.

Explore how modern agents decide when to call tools versus respond directly, using tool metadata and language model orchestration to achieve user objectives.

Observe how an agent plans, selects tools, and executes actions in real time with a coding client, then reads and edits a readme via tool calls to deliver the result.

Learn the MCP protocol, its revolutionary approach to building agents, and set up your environment to create, debug, and run an MCP server with a client in VS Code.

Learn how the model context protocol connects MCP clients to MCP servers, enabling shared tools, remote tool execution via JSON RPC, and scalable cross-agent tooling.

Explore popular MCP clients that connect tools to AI agents, including Visual Studio Code, ChatGPT, Cursor, Tray, and Postman, and learn to run MCP servers across these apps.

Explore common MCP servers, compare maintained reference servers from anthropic, and assess open-source options from cursor, VS Code, and other listings for secure deployment.

Install an MCP server using a publisher’s MCP setup, configure with the MCP JSON object and env API key in VS Code, and verify tools like Fire Crawl for scraping.

Set up a Python MCP server project with the uv package manager, create and activate a virtual environment, manage dependencies in pyproject.toml, and run the server with uv run main.py.

Install and create a simple MCP server using the Python SDK and fast MCP. Define tools with docstrings and type hints, then run the server locally using stdio.

Learn to debug an SMTP server using the model context inspector, connect to the MCP server, and run tools to validate JSON RPC messages over the selected protocol.

Install and start your MCP server, configure it in your MCP client (example: VS Code), and test with a mock tool to discover and use functions.

Introduce APIs to beginners by showing how they work, how to call and test them with Bruno, and how to turn free public APIs into MVP servers.

Understand that an API is an application programming interface that connects a front end to a back end via endpoints and HTTP requests to fetch data.

Explore public APIs and generous free tiers for personal projects. Connect weather, news, books via Gutenberg and Gmail APIs, and learn pricing, localhost testing, and deploying an MVP server.

Register a new API and test it with Bruno or another client to query Google News endpoints, adjust country and category filters, and view top headlines.

Discover how HTTP methods power API communication, with Get for reading data and Post for sending or creating resources, plus security considerations.

Learn to fetch data with Python using requests to call a top headlines API, encode parameters, handle API keys, and print JSON results for an MCP tool.

Connect your MVP server to external services via APIs to empower your AI assistant. Test get endpoints with Bruno, Postman, or Insomnia, and use a Google Colab notebook.

Select three free public APIs from the repository, test calls in Colab or an IDE with your API client, and share results in Q&A before continuing MCP servers.

Build a complete MVP server connected to an API that fetches and searches latest news using a large language model and news API.

Turn a validated API into an amqp server by following the MCP server development docs, using the LM TXT file and SDK docs, and deploying via VS Code.

Set up a new MVP MCP server in VS Code by initializing a Python 3.11 project, creating a virtual environment, installing dependencies, and using Copilot to generate the server code.

Build an MCP server with LLMs by supplying the model context protocol and SDK docs, then deploy using the Python SDK's fast MCP interface to integrate the genius API.

Review how the MCP server handles API keys, uses a reusable fetch helper, and validates parameters for languages, countries, categories, and headlines.

Debug the MCP server over stdio using the MCP inspector, restart the connection, and test tools like get top headlines and search news with language and country parameters.

Connect an MCP server to an MCP client in VS Code, configure absolute paths and API keys, and test with a voice-enabled Jarvis assistant to fetch top headlines.

Select one api and build an MCP wrapper for ai assistant. Send docs to your ai assistant, debug with MCP inspector, test in VS Code, and share results in Q&A.

Explore how transports enable MCP server communication through client-server architecture and json-rpc messages, and review available transports such as stdio and streamable http, noting http replaces sec.

Understand client-server architecture in the MCP framework by separating toolkits (MCP servers) from MCP clients, which call server tools via a backend fast API application.

Explore how the LM agent calls a function on the MCP server using JSON RPC messages (method, parameters, id), and how transports carry these requests to the server.

Learn how MCP transports enable json-rpc communication between a client and server, using stdio for local setups and streamable http for remote servers.

explore the security of MCP servers, learn how malicious MCP servers operate, and understand why you should verify sources before installing them, including SMTP and stdio transport implications.

Explore MCP's security model: what an agent sees when calling a function, including messages, tool descriptions, and parameters, and guard against malicious servers via stdio transport.

Demonstrates how a malicious MCP server can execute a command via subprocess, log outputs to MCP daemon logs, and highlights securing practices by reviewing tool calls.

Explore remote NTP servers accessible via HTTP, running them locally or in the cloud. Learn to mount multiple NTP servers in a single FastAPI app and deploy with Render.

Learn how Streamable HTTP enables remote MCP servers, shifts execution to the cloud, and simplifies setup with the Python SDK.

Create a remote MCP server over streamable http, configure host and port (default 8000 or 10000 on localhost), and debug with the MCP inspector in VS Code.

Connect to a remote MCP server by configuring a http remote server on localhost:10000/mcp and add the docs database tool, then test documentation retrieval from the database.

Mount your existing MCP server into a FastAPI application to build a robust backend with authentication and OAuth endpoints, using a context manager and uvicorn for deployment.

Mount multiple MCP servers in a single FastAPI app, including an email MCP with tools like get emails and write email, using an async exit stack to orchestrate servers.

Learn to implement authentication for MCP servers and enforce authorization scopes. Explore why remote MCP servers require OAuth 2.1, and build an authentication layer using scale kit with token validation.

Learn why authentication is essential for MCP servers, joining GUI and API security with a third interface for agents, and how to protect data like databases, APIs, calendars, and events.

Explain why local MCP authentication via API keys is unsuitable for non-technical users, citing installation complexity and security risks, and outline the shift to stateless remote MCP servers.

Shift to remote, HTTP-based MCP servers with centralized hosting, stateless design, and OAuth 2.1 authentication to securely connect agents and enterprise services.

Discover how OAuth 2.1, the official MCP standard, enables client and server authentication through authorization flows and JSON web tokens, with scale kit simplifying token validation and discovery.

Demonstrates the OAuth 2.1 workflow from a client perspective, guiding token retrieval via well-known endpoints, authorization server discovery, and JWT validation to execute tool calls.

Initialize a fast MCP server on localhost:10000, mount it at /MCP in a fast API app with a session manager and middleware, and prepare to add authentication.

ScaleKit offers a modular authentication stack for MCP servers, enabling quick dashboard setup, MCP server creation, dynamic registration, and scoped permissions like search read with a generous free tier.

Create a new endpoint with the exact authentication path, paste the stringified json into the metadata response, load it as json, and return the data as the first step.

Build and integrate an authentication middleware for a FastAPI app, exposing well-known endpoints openly and returning a bearer token challenge with a resource metadata URL for MCP clients.

Implement bearer token validation for the MCP server using middleware. Validate issuer, audience, and scopes from JWT with SQL Kit, including tool call scopes like search:read.

Restart the MVP server in VS Code, authorize Google login, and verify the web search capability by performing a test query to confirm auth in action.

Develop a capstone project by building an MCP server driven agent that uses rag with documents, embeddings, and vector databases to chat with unstructured data sources.

Explain how retrieval-augmented generation uses ETL, vector databases, and retrieval to answer questions with domain-specific or real-time data, illustrated by a device reset example.

Demonstrate the rag pipeline for unstructured data, covering extraction, chunking, and embedding into a vector database. Retrieve relevant chunks to feed the language model for answer generation.

Learn how embeddings convert text into high-dimensional numerical vectors that capture meaning in a semantic space, enabling similarity search and efficient retrieval with vector databases for Rag.

Store your text embeddings in the Chroma vector database to enable semantic search by finding the most similar vectors, powering question answering with large language models.

Transform a simple rack into an agent rack system that uses tools to query a vector database, ingest files, and manage status, enabling autonomous reasoning with RAG.

Test MCP server tools in a Jupyter notebook to debug functions, then set up the development environment, initialize the Chrome ODB vector database, and create a rag mcp collection.

download training papers, set up rag with lambda index, extract text with llama parse and simple directory reader, then ingest into a vector database with embeddings.

Learn to ingest documents into a vector database by replacing and recreating the collection, then vectorize with Chrome ODB’s transformers sentence transformer model.

Develop a vector-database query tool to retrieve the two relevant documents for a query, format results with metadata and distances, and implement the query_documents function for an MCP rag server.

Initialize a new MCP server project named simple and plug tools into an agent. Install uv to bundle Python, configure pyproject.toml and gitignore, and start building the server environment.

Install dependencies with uv to bootstrap fast MCP, initialize Chrome ODB with a persistent client and collection, load env vars, and prepare a data ingestion function for the data directory.

Load environment variables from a .env file, configure the data directory and cloud key, then ingest documents and parse PDFs with llama parse for MCP server tooling.

Initialize the MCP server with fast MCP, turn a script into an MCP tool with a descriptive docstring, ingest data into Chrome ODB collection, then inspect with the MCP inspector.

Test the MCP tool with the MCP inspector to debug without an agent, using npm to install the latest model context protocol inspector.

Turn the query documents function into an MCP tool, named 'Query Documents', to query the vector database for documents similar to a query, returning up to two results with metadata.

Add and commit the project to git with env, data, and chrome db ignored, then create a status tool that returns the vector database's ingested count and MCP server readiness.

Learn to test an MCP server as a remote service using ngrok and Hugging Chat, connect your local server to the web, and validate vector database status.