@letoribo1
Yuriy ChistyakovFounder▲5
GraphQL & MCP Integration Engineer | Real-Time Systems Architect, Independent
40m ago · Infra · Odesa

Stop building MCP servers with 100 tools. My server has exactly 2.

Hey everyone! Glad to be here.
One trend I've noticed in today's MCP ecosystem is creating what I believe is an avoidable architectural problem.

As APIs grow, MCP servers often expose dozens or even hundreds of individual tools by wrapping every API route, database table, or domain action as a separate operation.

The result? Massive context bloat, token exhaustion before the agent even starts thinking, and degraded tool-selection accuracy.

Worse yet is the security and liability aspect. Once an MCP server exposes 100+ raw tools, its author can no longer realistically reason about every possible interaction surface exposed to an LLM.

I took a different approach with @letoribo/mcp-graphql-enhanced.

Instead of tool sprawl, my server has exactly as many tools as a human needs for pure happiness: precisely 2.

  • introspect-schema
  • query-graphql

By leveraging GraphQL's inherent type system, AST manipulation, and strict schema contracts, the bridge acts as a unified architectural shield over any underlying resolver.

1. Surgical Context Control
Instead of dumping megabytes of definitions into the context window, introspect-schema returns a lightweight Federated Manifest first, allowing agents to request specific types with bounded typeDepth only when needed.

2. Schema-Adaptive Federation
query-graphql can broadcast across multiple heterogeneous GraphQL environments, including graph databases, APIs, and local or remote SDLs.

Queries are automatically pruned against each node's capabilities before execution, allowing a single request to safely operate across schemas that only partially overlap.

  1. Zero Tool Bloat & Guaranteed Guardrails

Whether you connect 1 endpoint or 10, the agent's tool surface never grows. Validation, security rules, and execution boundaries remain centralized in the schema rather than being scattered across hundreds of individually exposed tools that no one can fully audit.

  1. Recent Validation

Recent experiments included federated execution across:

  • GitHub GraphQL API
  • Neo4j GraphQL (@neo4j/graphql)
  • Custom GraphQL environments

The same query layer successfully handled endpoint-specific fields through schema-adaptive AST pruning and response aggregation.

I deliberately avoided including a single "quick example" here.
The architecture is not tied to one use case. It works equally well with graph databases, federated APIs, local or remote SDLs, capability discovery workflows, retrieval systems, and agent memory pipelines.

I didn't want the project pigeonholed into a single setup.

The schema is the interface.

What I'm Looking For

  • Architectural discussions around context optimization, dynamic schema routing, and multi-node agent memory.
  • Contributors interested in federated query planning, schema adaptation, and lean MCP transport layers.
  • Builders who are trying to reduce tool sprawl without sacrificing capability.

I'd love to hear how you're approaching tool proliferation, discoverability, and safety in your own agent stacks.

AgentsTools

Comments

No comments yet
Start the conversation.
Log in to join the thread.