Module 8: Project — Real-World MCP Server

End-to-End Demo: Claude Code + Your MCP Server

Capsule description

Your MCP server has complete code, tests that pass, and documentation. The most important thing is missing: demonstrating that it works in the real world. In this capsule you connect your server to Claude Code, use it in 5 real scenarios, do the final checklist, and reflect on what you built.

This capsule is also a celebration. You built a production-ready MCP server from scratch. That's not trivial. Let's take a moment to appreciate what that means.

Step 1: Configure the server in Claude Code

Register the server

Open your terminal and register the server with Claude Code:

claude mcp add task-manager \
  /full/path/task-manager-mcp/.venv/bin/python \
  -e PYTHONPATH=/full/path/task-manager-mcp \
  -- /full/path/task-manager-mcp/src/server.py

Replace /full/path/task-manager-mcp with the real path to your project. You can get it with pwd inside the project's directory.

For Option B (TypeScript):

claude mcp add project-analyzer \
  node \
  -- /full/path/project-analyzer/dist/index.js

For Option C (external API):

claude mcp add todoist-integration \
  -e TODOIST_API_KEY=your_token_here \
  /full/path/.venv/bin/python \
  -e PYTHONPATH=/full/path/todoist-mcp \
  -- /full/path/todoist-mcp/src/server.py

Verify the connection

claude

Inside Claude Code:

> /mcp

You should see:

task-manager
  Status: connected
  Tools: create_task, list_tasks, update_task, delete_task, search_tasks,
         create_category, run_query, get_task_summary
  Resources: taskdb://tables, taskdb://table/{table_name}/schema,
             taskdb://stats, taskdb://tasks/overdue, taskdb://categories
  Prompts: analyze_table, weekly_report, optimize_query

If the status is "connected" and you see all the tools, resources, and prompts, the connection is successful. This is the moment where everything you built materializes — your code went from being files on disk to being capabilities that Claude Code can use.

Take a moment to appreciate this. You wrote a server. You registered it in Claude Code. And now Claude Code knows how to do things it didn't know how to do before — because you gave it those capabilities.

If the connection fails

"Status: error" or "Status: disconnected":

# Verify that the server runs standalone
cd /full/path/task-manager-mcp
source .venv/bin/activate
PYTHONPATH=. python src/server.py

If the server errors standalone, there's a problem in your code (probably an import error). Fix it before continuing.

"No tools found":

The server connected but didn't register anything. Verify that src/server.py calls mcp.tool(), mcp.resource(), and @mcp.prompt() correctly. Run it in MCP Inspector to diagnose.

"Permission denied":

Verify that the path to the virtualenv's Python is correct and has execution permissions:

ls -la /full/path/task-manager-mcp/.venv/bin/python

Step 2: Demo — 5 real scenarios

Now the fun part. You're going to use your MCP server in 5 scenarios that demonstrate different capabilities. Each scenario shows a distinct aspect of the server.

Scenario 1: Explore the database

What you demonstrate: Resources work — Claude Code can read your database's structure.

Inside Claude Code:

> What tables does my task database have? Give me the structure of each one.

What should happen:

Claude Code reads the resource taskdb://tables to see the available tables
Claude Code reads taskdb://table/tasks/schema, taskdb://table/categories/schema, etc.
Claude Code presents you with a clear summary of the structure

Expected result: Claude Code shows the 4 tables (tasks, categories, tags, task_tags) with their columns, types, and relationships. Something like:

Your database has 4 tables:

1. **tasks** (10 records) — The main table with fields: id, title,
   description, status, priority, category_id, due_date, created_at, updated_at

2. **categories** (4 records) — Categories: id, name, description, color

3. **tags** (5 records) — Tags: id, name

4. **task_tags** — Many-to-many relationship between tasks and tags

If it fails: The resource taskdb://tables isn't returning data. Verify in MCP Inspector that the resource responds and that the database has data (seed data).

Why this scenario matters: It demonstrates the foundation of everything — that Claude Code can understand your data's structure before operating on it. In the real world, a developer would ask Claude Code to "understand this database" as a first step before making queries or writing code.

Scenario 2: Task management (CRUD)

What you demonstrate: Create, read, update, and delete tools work end-to-end.

Inside Claude Code, make a sequence of requests:

Request 1 — Create:

> Create a task "Prepare the MCP server presentation" with high priority,
  DevOps category, and due date March 25, 2026. Add the tags
  "demo" and "presentation".

Claude Code should use create_task and confirm the creation with the assigned ID.

Request 2 — List:

> Show me all the high-priority tasks

Claude Code should use list_tasks with a priority filter and show the tasks, including the one you just created. Verify that the new task appears in the list.

Request 3 — Update:

> Change the status of the task "Prepare the MCP server presentation" to in progress

Claude Code should use update_task to change the status to in_progress.

Request 4 — Verify:

> What's the current status of my tasks? Give me a quick summary.

Claude Code could use get_task_summary or list_tasks to show the current status, where the presentation task appears as "in_progress".

Scenario 3: Search and analysis

What you demonstrate: Search tools and custom queries work with real data.

Request 1 — Search:

> Search for tasks that mention "bug" or "fix" in the title or the description

Claude Code should use search_tasks and find the task "Fix pagination bug" from the seed data.

Expected result: Claude Code returns the task with its complete information, including that it already has status "completed" and priority "critical".

Request 2 — Custom query:

> Run a query to see how many tasks there are for each status and priority

Claude Code should use run_query with something like:

SELECT status, priority, COUNT(*) as count
FROM tasks
GROUP BY status, priority
ORDER BY status, priority

Request 3 — Analysis with data:

> Which are the overdue tasks that need urgent attention?

Claude Code could use the resource taskdb://tasks/overdue or the run_query tool to find tasks with a past due_date.

Expected result: Claude Code identifies the tasks with a due_date before today and a status other than "completed" or "cancelled", showing how many days overdue each one is.

Why this scenario matters: It demonstrates that your server can answer business questions — not just do CRUD. The difference between a useful MCP server and a mediocre one is that the useful one answers questions that matter.

Scenario 4: Use prompts

What you demonstrate: Prompts standardize complex interactions.

Request 1 — Table analysis:

> Use the analyze_table prompt to analyze the tasks table

Claude Code should run the analyze_table prompt, which internally:

Reads the table's schema
Queries the record count
Sees a sample of data
Generates a complete analysis with recommendations

Expected result: A detailed analysis that includes the table's structure, data distribution by status and priority, and suggestions of indexes or improvements.

Request 2 — Weekly report:

> Generate a weekly productivity report

Claude Code should run the weekly_report prompt, which combines multiple tools and resources to generate a complete report.

Expected result: A structured report with completed, pending, and overdue tasks, and recommendations. The report should feel like something a project manager would generate — not like a JSON dump.

Why prompts are powerful: Without the prompt, you'd have to tell Claude Code step by step what to query and how to format it. With the prompt, a single sentence generates a complete report. That's the difference between a tool and a platform.

Scenario 5: Complex multi-step flow

What you demonstrate: Claude Code can chain multiple tools and resources in a natural flow.

> I want to reorganize my tasks. First show me the categories that exist
  and how many tasks each one has. Then create a new category called "Urgent"
  with red color (#FF0000). After that, show me the "critical" priority tasks
  and suggest which ones should move to the "Urgent" category.

What should happen:

Claude Code reads taskdb://categories to see the current categories
Claude Code uses create_category to create "Urgent"
Claude Code uses list_tasks with a critical priority filter
Claude Code analyzes the tasks and suggests which ones to move

This scenario demonstrates that your server supports complex flows where Claude Code makes decisions based on data from your database. It's the scenario closest to a real production use — where you don't ask it to "run this specific tool" but rather describe a goal and Claude Code decides how to use the available tools.

Why it's the most important scenario: In the real world, your requests to Claude Code will be like this: complex, multi-step, with intermediate decisions. If your server supports this type of flow, it supports anything.

Step 3: Evaluate the demo's quality

After each scenario, evaluate not just whether "it worked" but how well it worked:

Evaluation criteria per scenario

Did Claude Code choose the correct tools? If Claude Code uses a different tool than expected but arrives at the correct result, that's a success — it demonstrates that your descriptions are good and that the model understands your server's capabilities.

If Claude Code doesn't use any tool from your server (and responds with general knowledge), something is failing in the connection or the descriptions.

Are the results correct? Verify manually that the data Claude Code presents corresponds to the real data in your database. A tool that returns incorrect data is worse than one that fails — because you don't realize the error.

Are the errors communicated well? Try provoking an error intentionally (e.g., ask to delete a task with ID 99999). Claude Code should communicate the error clearly, not show a stack trace.

Does the flow feel natural? If you have to explain to Claude Code exactly which tool to use and with which parameters, the descriptions need improvement. A natural flow looks like this: you describe what you want, and Claude Code decides how to get it.

Tips for a successful demo

Prepare the database with interesting data

The seed example data is a good starting point, but add data specific to your domain. If your server is for task management, add real tasks you have pending. Real data makes the demo feel authentic.

Start simple, scale the complexity

Don't start with scenario 5 (complex multi-step). Start with scenario 1 (explore the DB). Each scenario that works gives you confidence for the next one. If something fails in scenario 1, it's easier to diagnose than if it fails in scenario 5.

Have MCP Inspector open in parallel

If something fails in Claude Code, you can quickly verify in MCP Inspector whether the problem is your server or the communication. MCP Inspector shows you the raw response of each tool/resource.

# In a separate terminal
PYTHONPATH=. mcp dev src/server.py

Record the screen (optional but recommended)

If you want to share your project or simply have a record, record the demo. You can use asciinema to record the terminal:

asciinema rec demo.cast
# ...do the demo...
# Ctrl+D to finish

Don't be afraid of errors

If something fails during the demo, treat it as an opportunity. Is the error message clear? Does Claude Code communicate it well? Can you diagnose and fix it on the spot? The ability to handle failures is part of being production-ready.

Step 4: Record the demo's results

After running the 5 scenarios, note the results:

Scenario	Result	Tools/Resources used	Notes
1: Explore DB	✅/❌
2: Task CRUD	✅/❌
3: Search and analysis	✅/❌
4: Prompts	✅/❌
5: Multi-step flow	✅/❌

If any scenario fails, diagnose:

Does the tool return an error? → Review the tool's code
Does Claude Code not use the correct tool? → Improve the tool's description
Does the server disconnect? → Check logs with claude mcp add ... 2>&1 | tee server.log
Is the result incorrect? → Verify the data in the database

Final project checklist

Code (40 points of the rubric)

Server runs without errors: PYTHONPATH=. python src/server.py
5+ tools implemented and functional
3+ resources implemented and functional
2+ prompts implemented and functional
Pydantic models with validation for each tool input
Consistent error handling in all the tools (try/catch, descriptive messages)
Type hints throughout the code
No dead code, unnecessary imports, or unused functions
Clean and organized file structure

Testing (20 points)

PYTHONPATH=. pytest -v passes all the tests
Happy path tests for each tool
Error case tests (nonexistent ID, invalid input, forbidden query)
Integration tests (complete CRUD flow)
Tests use an in-memory database (they don't touch data/tasks.db)

Documentation (15 points)

README.md with installation instructions
Table of all the tools with parameters
Table of all the resources with URIs
Table of all the prompts
Instructions to connect to Claude Code
At least 3 usage examples

Demo (10 points)

Server connected to Claude Code (status: connected in /mcp)
5 scenarios executed successfully
Claude Code uses the tools naturally
No crashes or errors during the demo

General quality (15 points)

Resources, Tools, and Prompts are correctly assigned
Resource URIs follow clear conventions
Tool descriptions are clear and useful for Claude Code
The server solves a real problem (it's not a toy example)
The project is something you'd keep using after the guide

Bonus scenarios: advanced cases

If the 5 main scenarios worked without problems, try these bonus scenarios that demonstrate edge cases and robustness:

Bonus 1: Error handling

> Delete the task with ID 99999

Claude Code should use delete_task and receive a "not_found" error. Verify that Claude Code communicates the error clearly: "The task with ID 99999 doesn't exist" — not a stack trace or a generic error.

Bonus 2: Invalid query

> Run this query: DELETE FROM tasks WHERE status = 'cancelled'

Your run_query tool should reject the query because it contains DELETE. Claude Code should explain that only SELECT queries are allowed.

Bonus 3: Special data

> Create a task "Review article: 'How to use MCP with accents'" with the description
  "Include sections on: ñ, accents (á, é, í, ó, ú) and special characters"

Verify that the Unicode characters are handled correctly — both in the creation and in the reading.

Bonus 4: Intensive use

> Create 5 new tasks: "Task Alpha" (high priority), "Task Beta" (low priority),
  "Task Gamma" (critical priority), "Task Delta" (medium priority),
  "Task Epsilon" (high priority). All in the Backend category.

Claude Code should create the 5 tasks one by one (or ask for approval for each one). Verify that all of them are created correctly.

Then:

> Show me a summary of all the tasks, grouped by priority

It should include the 5 new tasks in the correct counts.

Scoring and self-evaluation

Use the rubric from capsule 01 to evaluate your project. Be honest — the self-evaluation is for you, not for a grade. The goal is to identify areas where you can improve.

Section	Possible points	Your score
Resources	15	/15
Tools	25	/25
Prompts	10	/10
Testing	20	/20
Documentation	15	/15
Demo	10	/10
Code quality	5	/5
Total	100	/100

Retrospective

Before closing the project, take 15 minutes to answer these questions. There are no correct answers — it's a reflection to consolidate what you learned. Write them down. The act of writing forces reflection in ways that "thinking about it" doesn't achieve.

About the process

What was the hardest part of this project? The design? The implementation? The tests? The Claude Code configuration? Most developers say the design was the hardest part — deciding what to expose and how to organize it requires a different kind of thinking than writing code.
What design decision would you change if you started over? Would you organize the tools differently? Would you choose another schema? Would you add more resources or prompts? There's no perfect design — but reflecting on what you'd change improves your next design.
What surprised you? Was something easier or harder than you expected? Many developers are surprised by how simple it is to register tools and resources with FastMCP, and by how complex it is to write good descriptions.

About MCP

When would you use resources vs tools? Did the distinction become clear after implementing both? The rule: if Claude Code needs it as context to decide → resource. If Claude Code runs it when the user asks → tool.
Are prompts useful? Would you use them regularly or just for demos? Prompts are more useful than they seem. A good prompt turns a flow of 5 requests into 1.
What tool would you add if you had more time? Is there a missing operation that would make the server more complete? This question is the seed of the next iteration of your server.

About production

Is your server really "production-ready"? What does it lack for you to trust it 100%? Probably: authentication, rate limiting, more robust logging, database backup, monitoring.
What would you do differently with the error handling? Are the error messages clear enough for Claude Code to communicate them well to the user? A good exercise: provoke all the possible errors and evaluate whether the messages are useful.
Do the tests cover the important cases? Are there edge cases you didn't test? Think about: empty inputs, very long strings, Unicode characters, simultaneous requests, a full database.

About the path

How does this project connect with your work? Do you see applications of MCP servers in your professional context? Think about the APIs and databases you use daily. Which ones would benefit from an MCP server?
Would you recommend MCP to a colleague? Why or why not? What would you tell them to convince them to try it?
Which skills from this guide will you use most frequently? The ability to build servers? The testing patterns? Designing APIs via MCP?

What comes next: beyond this guide

You completed the guide. You have a production-ready MCP server that Claude Code uses. That's a significant achievement — most developers haven't built a custom integration for their AI assistant.

But this is only the beginning. Here are paths to keep growing:

Improve your current server

Before building something new, your current server has room to grow:

More tools:

batch_update_tasks — Update multiple tasks at once (e.g., "mark all the DevOps category tasks as completed")
get_task_history — If you implement a change log, see a task's history
export_data — Export data in CSV or JSON
import_data — Import tasks from a file

More resources:

taskdb://tasks/today — Tasks with a due_date today
taskdb://tasks/recent — Last 5 tasks created/modified
taskdb://health — Server health check (database accessible, version, uptime)

More prompts:

daily_standup — "What did I do yesterday? What will I do today? Are there any blockers?"
sprint_planning — Plan the next week based on pending tasks and priorities
retrospective — Analysis of what was completed vs planned in a period

Infrastructure features:

Caching for resources that don't change frequently
Structured logging with levels (debug, info, warning, error)
Usage metrics (which tools are used most, response times)
Configuration via environment variables (DB path, log level, etc.)

Publish your server

Public GitHub repo: Share your server so others can use it
Detailed README: Good READMEs make the difference between a repo nobody looks at and one with stars
PyPI / npm: Publish it as an installable package
MCP Registry: If a centralized registry of MCP servers exists, register yours

Build more MCP servers

Now that you know how the pattern works, you can build servers for any service:

Service	Resources	Tools
Notion	Pages, databases, blocks	Create page, update, search
Slack	Channels, recent messages	Send message, search, list channels
PostgreSQL	Tables, schemas, metrics	CRUD, queries, migrations
AWS S3	Buckets, objects, storage stats	Upload, download, list, delete
Docker	Containers, images, volumes	Run, stop, logs, build
Jira	Issues, sprints, boards	Create issue, assign, transition

Each of these follows the same pattern you used in this project:

Define the domain and the operations
Map to resources, tools, and prompts
Implement with the SDK
Test
Connect to Claude Code
Document

The pattern repeats. What changes is the data and the operations. Your second MCP server will take you half the time of the first.

Explore advanced MCP features

Sampling: The server asks the host to generate text with the LLM (inverse loop)
Roots: Define directories the server can access (sandboxing)
SSE Transport: Remote servers accessible via HTTP (not just local stdio)
Multi-server: Claude Code using multiple MCP servers simultaneously
Custom notifications: The server notifies the host of changes in data

Contribute to the ecosystem

Report bugs: If you find problems with the SDK, open issues on GitHub
Improve documentation: The SDKs are new — every contribution to docs helps
Open source servers: Contribute to existing MCP servers or create new ones for popular services
Community: Share what you learned — blog posts, talks, tutorials
Mentor: Help other developers create their first MCP server — you already know how

The complete map: where you come from

Let's take stock of everything you accomplished in this guide. Each module built on the previous one, and this project integrated everything:

Module 1: You understood the problem

The M×N integration problem and how MCP solves it with the M+N model. The USB-C analogy. The ecosystem.

Module 2: You understood the architecture

Host → Client → Server. The complete flow of a request. Roles and responsibilities of each component.

Module 3: You mastered the primitives

Resources for contextual data. Tools for operations with side effects. Prompts for reusable templates.

Module 4: You built in TypeScript

MCP server with the TypeScript SDK. Zod schemas. Transports (stdio, HTTP/SSE).

Module 5: You built in Python

MCP server with FastMCP and decorators. Pydantic. Async patterns. GitHub API.

Module 6: You created MCP Apps

Interactive UI as tool output. Dashboards. Forms.

Module 7: You professionalized

Testing with Vitest and pytest. Debugging with MCP Inspector. Configuration in Claude Code. Troubleshooting.

Module 8: You built something real

A production-ready MCP server connected to a real database. With tests. With documentation. Working in Claude Code.

In numbers

Think about what your project includes:

8+ tools that Claude Code can invoke
5+ resources that Claude Code can read for context
3 prompts that automate complex flows
30+ tests that verify everything works
1 README that lets anyone install your server
1 database with real data
5 scenarios demonstrated end-to-end

That's not a tutorial exercise. That's a functional custom integration.

The "I built that" moment

Open Claude Code. Ask it a question that only your MCP server can answer. Watch how it uses your tool. Watch how it returns data from your database. Watch how it follows your prompt's template.

You built that.

You didn't copy a tutorial. You didn't install someone else's server. You designed the architecture, wrote the code, tested each piece, documented everything, and connected it to Claude Code.

Claude Code can now do things it couldn't do before — because you gave it those capabilities.

That's the power of MCP. Every developer who understands the protocol can extend what an AI assistant can do. They can turn any API, any database, any service, into something the AI uses natively.

And now you know how to do it.

Before and after

Think about where you were at the start of this guide vs where you are now:

Before	After
"MCP is... something from Anthropic?"	"MCP is the standard protocol that connects AI hosts with external services"
"Claude Code can only read and write files"	"Claude Code can do anything it has an MCP server for"
"I don't know how to extend my AI assistant"	"I can build an MCP server for any API or database"
"Tools are framework black magic"	"Tools are Python functions with Pydantic validation that I register with a decorator"
"Testing AI integrations is impossible"	"I use in-memory databases and patches to test each tool"
"Production-ready means deploying to the cloud"	"Production-ready means robust code, tests, documentation, and error handling"

That transformation is the goal of this guide. And the evidence that you completed it is running in your Claude Code right now.

Share your project

If you want to share your project (and you should), here are the steps:

Prepare for GitHub

cd task-manager-mcp

# Verify that .gitignore is good
cat .gitignore

# Initialize the repo if you don't have it
git init
git add .
git commit -m "MCP server: task manager with SQLite"

Checklist before publishing

.gitignore includes .venv/, __pycache__/, data/tasks.db
There are no tokens or credentials in the code
README.md has complete installation instructions
The tests pass in a clean environment (clone the repo and test)
The seed data doesn't contain personal information

Why share?

Portfolio: A functional MCP server demonstrates concrete technical skills
Feedback: Other developers can find bugs or suggest improvements
Community: The MCP ecosystem grows when more developers publish servers
Future reference: Your future self will thank you for having a complete documented example

Demo troubleshooting

"Claude Code doesn't use the tool I expected"

Claude Code chooses which tool to use based on your request and the tools' descriptions. If it doesn't use the correct tool:

Be more explicit: "Use the search_tasks tool to search for..."
Improve the tool's description — add more context about when to use it
Review the instructions field of FastMCP() — it tells the model what your server can do

"The server disconnects during the demo"

Your server probably has an error that causes a crash. To diagnose:

# Verify that the server runs standalone
cd task-manager-mcp
PYTHONPATH=. python src/server.py

If there's an import or initialization error, it appears here. Fix it and reconnect:

claude mcp remove task-manager
claude mcp add task-manager ...

"Claude Code asks for permission for each tool"

It's the expected behavior. Claude Code asks for approval before running tools (because they have side effects). You can approve with "y" or "a" (yes / allow). To approve all the tools for a session, use "a" on the first invocation.

"The data doesn't reflect the changes I made"

Your server uses SQLite with WAL mode. The changes should reflect immediately. If they don't:

Verify that get_connection does conn.commit() (the context manager does it automatically)
Verify that there isn't another instance of the server reading a different database
Run run_query with SELECT * FROM tasks ORDER BY id DESC LIMIT 5 to see the most recent data

"The prompts don't do what I expected"

Prompts generate text that instructs Claude Code about which tools and resources to use. If the result isn't what you expected:

Review the prompt's template — are the instructions clear?
Verify that the tools and resources mentioned in the prompt exist
Try running the prompt's steps manually (one by one) to see where it fails

"Error: MCP server task-manager timed out"

The server takes too long to initialize. Common causes:

The database is very large (millions of records) — reduce the seed data
An import takes a long time — verify that you're not importing heavy packages at the top level
Error in init_database() or seed_sample_data() — test it standalone first

"Claude Code says it doesn't know that tool/resource"

The server connected but the registrations failed. Verify:

# Re-register
claude mcp remove task-manager
claude mcp add task-manager ...

# Verify
claude
> /mcp

If you still don't see the tools, the problem is in how you register tools in server.py. Compare with the code from capsule 03.

Your server in the context of the Claude Code Agentic Development Path

This server doesn't live in a vacuum. It's a piece of the complete path:

Guide	How it connects with MCP
Guide 1: Intro to Claude Code	You learned to use Claude Code — now you extended it
Guide 2: Prompt Engineering	The tools' descriptions are applied prompt engineering
Guide 3: Agentic Workflows	Your server enables more powerful agentic flows
Guide 4: CLAUDE.md & Memory	You can document your MCP server in CLAUDE.md for persistent context
Guide 5: MCP (this one)	You built the integration
Guide 6: Debugging & Code Review	You'll use your knowledge of tools to debug better
Guides 7-11	MCP servers as part of your professional toolkit

With each guide you complete, your MCP server becomes more useful. And with each MCP server you build, your capability with Claude Code grows.

Guide closing

You've completed the 8 modules of Claude Code & MCP: Building Custom Integrations. You started without knowing what MCP was and finished with a production-ready server running in Claude Code.

The Claude Code Agentic Development path continues with Guide 6: Debugging & Code Review with Claude Code. The skills you acquired here — understanding how Claude Code communicates with external tools, how tools process data, how errors propagate — give you a significant advantage for debugging AI-generated code.

Your MCP server doesn't end here. Add tools to it when you find operations you repeat. Improve the prompts when you discover interaction patterns. Share it if you think others can use it.

You built something real. That's what matters.

Summary

You configured your MCP server in Claude Code and verified the connection with /mcp
You ran 5 real scenarios that demonstrate the server's value in development workflows
Your server passes the 100-point rubric: functional code, tests, documentation, and demo
You completed the final checklist of quality and functionality
You identified areas for improvement and future extensions for your server
You reflected on everything learned across the 8 modules of the guide
Your MCP server is a portfolio project that demonstrates mastery of MCP, Python, SQLite, and testing

Resources

MCP Specification — Complete specification of the protocol
MCP Python SDK — Official Python SDK
MCP TypeScript SDK — Official TypeScript SDK
Awesome MCP Servers — Collection of open source MCP servers
Claude Code Documentation — Official Claude Code documentation
Claude Code MCP Guide — Configuration of MCP in Claude Code
Model Context Protocol Blog — Original MCP announcement
MCP Inspector — Visual debugging tool

← PreviousTesting and Documentation