Chapter 37: Further Reading

Custom Tools, MCP Servers, and Extending AI

Standards and Specifications

  1. Anthropic. (2025). "Model Context Protocol Specification." modelcontextprotocol.io. The authoritative specification for MCP, covering the full protocol including initialization handshakes, tool schemas, resource URIs, prompt templates, transport mechanisms (stdio, SSE, Streamable HTTP), and JSON-RPC 2.0 message formats. This is the primary reference for anyone implementing an MCP server or client. Read the specification alongside Section 37.2 of this chapter for a complete understanding of every protocol detail discussed in the text.

  2. JSON Schema. (2020). "JSON Schema: A Media Type for Describing JSON Documents." json-schema.org. The specification for JSON Schema, which MCP uses to define tool input parameters. Understanding JSON Schema is essential for writing effective tool schemas with proper type constraints, validation rules, default values, and descriptive metadata. The "Understanding JSON Schema" tutorial on the same site provides a gentler introduction than the formal specification.

  3. JSON-RPC Working Group. (2013). "JSON-RPC 2.0 Specification." jsonrpc.org. The specification for JSON-RPC 2.0, the message format underlying all MCP communication. While you do not need to implement JSON-RPC yourself (the mcp library handles it), understanding the specification helps when debugging protocol issues, reading server logs, or using the MCP Inspector tool to examine raw messages.

Technical Documentation and Guides

  1. Anthropic. (2025). "MCP Python SDK Documentation." GitHub: modelcontextprotocol/python-sdk. The official documentation for the Python SDK used throughout this chapter to build MCP servers. Covers the Server class, decorator-based handler registration, transport setup, and type definitions. The repository also includes example servers that demonstrate patterns beyond those covered in this chapter, including advanced resource subscriptions and progress notifications.

  2. Anthropic. (2025). "MCP TypeScript SDK Documentation." GitHub: modelcontextprotocol/typescript-sdk. The TypeScript SDK for MCP, which provides an alternative implementation language for MCP servers. Reading both the Python and TypeScript SDKs gives you a deeper understanding of the protocol by seeing how the same concepts are expressed in different languages. The TypeScript SDK is particularly relevant if your team's infrastructure is JavaScript-based.

  3. Anthropic. (2025). "Claude Code Documentation: MCP Server Configuration." docs.anthropic.com. The official guide for configuring MCP servers in Claude Code, including the .claude/settings.json format, the /mcp command for interactive server management, and best practices for local and project-level server configuration. This documentation is essential for deploying the servers you build following this chapter's examples.

  4. Anthropic. (2025). "Claude Code Documentation: Custom Slash Commands." docs.anthropic.com. The official guide for creating custom slash commands in Claude Code, covering project-level commands (.claude/commands/), user-level commands (~/.claude/commands/), the $ARGUMENTS placeholder, and subdirectory-based command organization. This documentation complements Section 37.6 with additional examples and configuration details.

Books

  1. Huyen, C. (2025). AI Engineering: Building Applications with Foundation Models. O'Reilly Media. Covers the broader context of building applications that integrate AI models with external tools and data sources. The chapters on tool use, evaluation, and production deployment provide practical guidance that applies directly to MCP server development. Particularly relevant for understanding how tool calling fits into larger application architectures.

  2. Fowler, M. (2002). Patterns of Enterprise Application Integration. Addison-Wesley. Although written before the AI era, this book's integration patterns---adapters, facades, message channels, and data transformers---map directly to the patterns used in MCP server development. The adapter pattern for wrapping data sources (Section 37.5), the middleware pipeline pattern (Section 37.7), and the registry pattern (Section 37.4) all have roots in these enterprise integration patterns.

Blog Posts and Technical Articles

  1. Anthropic. (2025). "Building Effective Agents." anthropic.com/research. Anthropic's practical guide to building reliable agent systems, with specific attention to tool design, error handling, and iterative improvement. The section on tool descriptions as prompts directly supports the design principles in Section 37.4. Reading this alongside Chapter 36 and this chapter provides a complete picture of how tools and agents work together.

  2. Anthropic. (2024). "Introducing the Model Context Protocol." anthropic.com/news. The original announcement of MCP, explaining the motivation, design philosophy, and vision for an open standard for AI tool integration. This post provides valuable context for understanding why MCP was designed the way it was, including the decision to support multiple transport mechanisms and the choice of JSON-RPC over alternatives.

  3. Willison, S. (2025). "Building MCP Servers in Python." simonwillison.net. A practitioner's guide to building MCP servers with extensive real-world examples, debugging tips, and lessons learned from deploying servers in production. Simon Willison's pragmatic perspective complements this chapter's structured approach with additional practical insights, particularly around error handling edge cases and performance optimization.

Tools and Resources

  1. Model Context Protocol Inspector. (2025). GitHub: modelcontextprotocol/inspector. The MCP Inspector is an interactive debugging tool for MCP servers. It provides a web interface for connecting to servers, listing tools and resources, invoking tools with custom arguments, and examining raw JSON-RPC messages. Learning to use the Inspector effectively is essential for the testing and debugging workflow described in Section 37.8.

  2. MCP Server Registry. (2025). GitHub: modelcontextprotocol/servers. The official registry of reference and community-built MCP servers. Studying existing servers is one of the best ways to learn MCP development patterns. The registry includes servers for file systems, databases, GitHub, Slack, and many other integrations. Before building a custom server, check this registry to see if an existing solution meets your needs.

  3. OWASP. (2025). "OWASP Top 10 for Large Language Model Applications." owasp.org. The OWASP guide to security risks in LLM applications, including sections on insecure tool use, excessive agency, and prompt injection attacks that can affect tool invocations. Every developer building MCP servers that access sensitive data or perform privileged operations should understand these risks. The security considerations in Section 37.9 are grounded in the threat models described in this resource.