Skip to main content

Protocol Comparison Guide

Overview​

BMCPS v3.0 is protocol-agnostic — it can generate blockchain AI integrations in multiple formats. This guide helps you choose the right protocol for your use case.

The Context Rot Problem​

At the AI Engineer Summit 2025, a critical limitation of MCP was identified: context rot. MCP loads all tool definitions (~5k tokens) into the AI's context window upfront, which:

  • Wastes valuable context space in long conversations
  • Reduces the room for actual conversation content
  • Becomes problematic for extended agent sessions

BMCPS v3.0 solves this by offering protocol flexibility — choose the format that best matches your context requirements.

Quick Comparison​

ProtocolContext OverheadBest ForSetup Complexity
REST API0 tokensProduction apps, high-scale systems, microservicesMedium
OpenAI Functions~500 tokensLong conversations, extended agent sessionsLow
MCP~5k tokensFeature-rich integrations, short interactionsLow
JSON SchemaN/ACustom protocols, base schemasN/A

Detailed Breakdown​

1. REST API (Zero Context Overhead)​

Context Cost: 0 tokens

node bmcps-generator.js --blockchain eth --format rest-api

✅ Best For:​

  • Production applications with high-scale requirements
  • Microservices architectures
  • Multiple AI agents accessing the same blockchain data
  • Web applications with frontend+backend separation
  • Public APIs for developer ecosystems

How It Works:​

  • Generates Express.js server with 25 REST endpoints
  • OpenAPI 3.0 specification for documentation
  • AI discovers endpoints via spec, makes HTTP requests
  • No tool schemas loaded into context

Example Generated Files:​

eth-mainnet-rest-api/
├── openapi.json          # OpenAPI 3.0 spec
├── server.js             # Express server (25 endpoints)
├── package.json          # Dependencies
├── .env.example          # Configuration
└── README.md             # Documentation

Pros:​

  • ✅ Zero context overhead - AI just needs endpoint URLs
  • ✅ Scales infinitely - standard HTTP infrastructure
  • ✅ Language agnostic - any HTTP client works
  • ✅ Caching friendly - use CDNs, load balancers
  • ✅ Observable - standard monitoring tools

Cons:​

  • ❌ Requires HTTP server deployment
  • ❌ Network latency for each call
  • ❌ Need authentication/rate limiting setup

When to Choose:​

"I'm building a production app that needs to scale to thousands of concurrent users"

2. OpenAI Functions (~500 Token Context)​

Context Cost: ~500 tokens

node bmcps-generator.js --blockchain btc --format openai

✅ Best For:​

  • Long conversations with many back-and-forth exchanges
  • Extended agent sessions (customer support, research)
  • GPT-4/GPT-4-turbo applications
  • Context-sensitive applications where every token counts

How It Works:​

  • Generates JSON function definitions for OpenAI's function calling API
  • AI receives compact function schemas
  • Only function calls appear in context, not full tool descriptions

Example Generated Files:​

btc-mainnet-openai/
├── functions.json        # 25 function definitions
├── example.js            # Usage example
└── README.md             # Documentation

Pros:​

  • ✅ Low context overhead (~90% less than MCP)
  • ✅ Perfect for long conversations - leaves room for history
  • ✅ Native OpenAI integration - built-in function calling
  • ✅ Simple deployment - just import JSON
  • ✅ Familiar API - standard OpenAI SDK

Cons:​

  • ❌ OpenAI-specific (not protocol-agnostic)
  • ❌ Still uses ~500 tokens for 25 tools
  • ❌ Requires custom function implementation

When to Choose:​

"I'm building a chatbot that needs to maintain long conversation history while accessing blockchain data"

3. MCP (~5k Token Context)​

Context Cost: ~5,000 tokens

node bmcps-generator.js --blockchain sol --format mcp

✅ Best For:​

  • Feature-rich integrations with full MCP capabilities
  • Short interactions (quick queries, single-use)
  • Claude Desktop or Claude.ai integration
  • Advanced features (prompts, resources, sampling)
  • Standardized tooling across multiple AI platforms

How It Works:​

  • Generates complete TypeScript MCP server
  • Full server/client architecture with stdio transport
  • Rich tool definitions with comprehensive schemas
  • Supports prompts, resources, and sampling (beyond just tools)

Example Generated Files:​

sol-mainnet-mcp-server/
├── src/
│   ├── index.ts                # MCP server entry point
│   ├── tool-definitions.ts     # Tool registry
│   └── tools/                  # 25 tool implementations
│       ├── core/
│       ├── wallet/
│       ├── network/
│       └── tokens/
├── tests/                      # Jest test suite
├── package.json
├── tsconfig.json
└── README.md

Pros:​

  • ✅ Feature-rich - prompts, resources, sampling
  • ✅ Standardized protocol - works across AI platforms
  • ✅ Complete implementation - full server + tests
  • ✅ TypeScript - type safety and autocomplete
  • ✅ Ecosystem support - growing MCP tooling

Cons:​

  • ❌ High context overhead (~5k tokens for 25 tools)
  • ❌ Not ideal for long conversations - eats context space
  • ❌ Requires stdio transport or server deployment
  • ❌ More complex than simple function calling

When to Choose:​

"I'm integrating with Claude Desktop and want the full MCP feature set for short, focused interactions"

4. JSON Schema (Format-Agnostic Base)​

Context Cost: N/A (not directly used by AI)

node bmcps-generator.js --blockchain avax --format json-schema

✅ Best For:​

  • Custom protocol development
  • Base schema for new formats
  • Documentation and reference
  • Validation of tool implementations

How It Works:​

  • Generates pure JSON schema with prefixed tool names
  • Includes all input/output definitions
  • Can be transformed into any other format

Example Generated Files:​

avax-mainnet-json-schema/
└── schema.json           # Universal tool schema

Pros:​

  • ✅ Format-agnostic - base for any protocol
  • ✅ Fully specified - complete tool definitions
  • ✅ Extensible - easy to transform

Cons:​

  • ❌ Not directly usable by AI agents
  • ❌ Requires custom implementation

When to Choose:​

"I'm building a custom protocol or need a base schema for tooling/validation"

Decision Tree​

Start: What's your use case?

├─ Building production app at scale?
│  └─ Use REST API (0 tokens)
│
├─ Long conversations (>10 exchanges)?
│  └─ Use OpenAI Functions (~500 tokens)
│
├─ Short Claude Desktop integration?
│  └─ Use MCP (~5k tokens)
│
└─ Building custom protocol?
   └─ Use JSON Schema

Migration Between Protocols​

One of BMCPS v3.0's superpowers is protocol migration. All formats are generated from the same universal schema, so you can:

Start with MCP, Migrate to OpenAI Functions​

  1. Prototype with MCP for quick testing
  2. Switch to OpenAI Functions for production conversations
  3. Use the same 25 tools, just different transport
# Start with MCP
node bmcps-generator.js --blockchain eth --format mcp

# Later: Switch to OpenAI for production
node bmcps-generator.js --blockchain eth --format openai

Start with OpenAI, Scale to REST API​

  1. Begin with OpenAI Functions for MVP
  2. As usage grows, deploy REST API for scalability
  3. Same blockchain operations, different protocol

Context Overhead Examples​

Long Conversation Scenario​

Conversation: 20 exchanges between AI and user about Ethereum transactions

ProtocolContext UsedRemaining for Conversation
REST API0 tokens100% available
OpenAI Functions500 tokens~99% available
MCP5,000 tokens~95% available

For a 8k token context window, the difference becomes significant:

  • REST API: 8,000 tokens for conversation
  • OpenAI: 7,500 tokens for conversation
  • MCP: 3,000 tokens for conversation

Short Query Scenario​

Conversation: Single "What's the balance of 0x123?" query

ProtocolImpact
REST APISlight HTTP overhead, zero context cost
OpenAI FunctionsMinimal - 500 tokens negligible for short chat
MCPNo problem - 5k tokens fine for one-off query

Verdict: For short queries, MCP's context overhead doesn't matter. Use whatever protocol integrates easiest.

Real-World Use Cases​

Use Case 1: DeFi Trading Bot (24/7 Operations)​

Recommendation: REST API

  • Why: Zero context, scales to thousands of trades, can cache responses
  • Command: node bmcps-generator.js --blockchain eth --format rest-api

Use Case 2: Blockchain Research Assistant (Extended Sessions)​

Recommendation: OpenAI Functions

  • Why: Needs long conversation history to discuss findings
  • Command: node bmcps-generator.js --blockchain btc --format openai

Use Case 3: Claude Desktop Plugin (Personal Use)​

Recommendation: MCP

  • Why: Short queries, want full MCP feature set
  • Command: node bmcps-generator.js --blockchain sol --format mcp

Use Case 4: Multi-Chain Portfolio Tracker (Web App)​

Recommendation: REST API

  • Why: Frontend needs data from multiple chains, users expect fast responses
  • Command: node bmcps-generator.js --blockchain eth --format rest-api

Generate All Formats at Once​

Not sure which protocol you'll need? Generate everything:

node bmcps-generator.js --blockchain eth --format all

This creates:

  • eth-mainnet-openai/ - OpenAI Functions
  • eth-mainnet-mcp-server/ - MCP Server
  • eth-mainnet-rest-api/ - REST API
  • eth-mainnet-json-schema/ - JSON Schema

Test each protocol and choose what works best!

Summary​

QuestionAnswer
Need maximum scale?REST API
Long conversations?OpenAI Functions
Claude Desktop integration?MCP
Custom protocol?JSON Schema
Not sure?Generate all (--format all)

Next Steps: