Multiple MCP tools, persistent graph memory, token-saving data pointers, and more.
io.neonia/cloud-backend MCP Server
The io.neonia/cloud-backend MCP server provides multiple MCP tools and supports persistent graph memory, along with token-saving data pointers. It is described as a collection of autonomous agent examples for integrating the Neonia Model Context Protocol (MCP) Gateway using the official Streamable HTTP transport standard.
🛠️ Key Features
Multiple MCP tools
Persistent graph memory
Token-saving data pointers
🚀 Use Cases
Integrating the Neonia MCP Gateway via Streamable HTTP transport
Addressing context window bloat in agent architectures
Reducing tool rigidity with agent patterns
⚡ Developer Benefits
Deterministic, high-performance agent example patterns
Illustrates practical MCP Gateway integration using Streamable HTTP
⚠️ Limitations
The provided description does not enumerate specific tool names, behaviors, or counts.
A collection of autonomous agent examples demonstrating how to integrate the Neonia Model Context Protocol (MCP) Gateway using the official Streamable HTTP transport standard.
About These Examples
This repository will continuously grow with new patterns demonstrating deterministic, high-performance AI agents.
Our first major showcases focus on solving two critical problems in modern agent architectures: Context Window Bloat and Tool Rigidity.
1. Solving Tool Rigidity (Auto-Pilot Discovery)
Agents are traditionally hard-coded with a static list of tools. If a user asks for something outside that list, the agent hallucinates or fails. The auto-discovery-url-to-markdown examples demonstrate how to give your agents true autonomy. By connecting to the Neonia Gateway, the agent can dynamically search for missing capabilities, read the tool's schema, and execute it on the fly without human intervention.
2. Solving Context Bloat (Zero-Bloat Data Processing)
Traditionally, when an agent needs to extract data from a large 5MB JSON file, it loads the entire file into its context window, causing massive token consumption, high latency, and LLM "amnesia". By connecting to the Neonia MCP Gateway (mcp.neonia.io/mcp?tools=neonia_data_jq_filter), our zero-bloat-jq-filter agents explicitly bind the Wasm-powered JQ Filter tool. The agent executes queries on the remote server and receives only the filtered result (e.g. $651,758.23), saving ~50,000+ tokens per request and responding almost instantly.
3. Stateful Memory Note (stateful-cloud-memory)
Agents typically suffer from absolute amnesia between sessions. If a user states a preference or business rule, it is lost unless hardcoded into the system prompt. The stateful-cloud-memory examples demonstrate how to create stateful agents that use Neonia's Dual Memory Architecture (neonia_sys_memory_note for writing and neonia_sys_memory_search for reading) to dynamically store and recall rules (like custom personas or user preferences) across completely isolated sessions without needing a custom database.
When agents learn hard architectural lessons, bug fixes, or strict operational rules, they need a way to persist this knowledge using a strict Cause-and-Effect structure (ADR). The persistent-knowledge-memory examples demonstrate using the neonia_sys_memory_lesson tool to save complex insights so future agents can fetch them using neonia_sys_memory_search before starting their tasks.
(More examples covering vision extraction, dynamic execution, and multi-agent orchestration will be added soon!)
Examples Provided
This repository includes implementations of "Zero-Bloat Data Processing", "Auto-Pilot Tool Discovery", and "Stateful Memory Note" across major agentic frameworks in 3 different languages:
1. Python (LangGraph)
A deterministic workflow using LangChain and LangGraph to build a reactive agent (create_agent) that dynamically wraps MCP capabilities into native LangChain @tool instances.
A self-assembling agent using Hugging Face's SmolAgents and LiteLLM. Demonstrates subclassing smolagents.Tool for synchronous forward execution wrapped around an asynchronous Streamable HTTP session.
An integration with the Vercel AI SDK utilizing the official @modelcontextprotocol/sdk and @openrouter/ai-sdk-provider. Demonstrates proper multi-turn tool calling and schema mapping for Claude 3.7 Sonnet.
A statically-typed integration using the Rig agent framework and rust-mcp-sdk. Demonstrates bridging an initialized MCP client session into Rust's strong type system.
Demonstrates how to give agents true autonomy. If an agent lacks a required capability, it dynamically searches the Neonia Gateway for a matching tool, reads its parameters, and executes it on the fly without human intervention.
2. Zero-Bloat Data Processing (zero-bloat-jq-filter)
Demonstrates how to safely process massive API payloads using a deterministic Wasm JQ filter at the edge, drastically reducing LLM token context usage and preventing hallucination.
3. Chained Data Execution (chained-json-jq-filter)
Demonstrates how to safely process massive API payloads using a chained data workflow. The agent uses neonia_web_json_fetch to retrieve remote JSON and stores it on the Gateway, returning a lightweight pointer. It then passes this pointer to a deterministic Wasm JQ filter (neonia_data_jq_filter) to extract exactly what it needs, keeping its context window incredibly small.
Demonstrates how to use the Dual Memory Architecture (neonia_sys_memory_note and neonia_sys_memory_search) to allow an agent to remember personas or business rules across completely isolated sessions.
Demonstrates how to use the Dual Memory Architecture (neonia_sys_memory_lesson and neonia_sys_memory_search) to allow an agent to record hard architectural lessons in a cause-and-effect format and retrieve them dynamically on new tasks.