Server data from the Official MCP Registry
Provides AI agents with persistent Graph Memory, dynamic tool discovery and secure execution.
Provides AI agents with persistent Graph Memory, dynamic tool discovery and secure execution.
Remote endpoints: streamable-http: https://mcp.neonia.io/mcp
Valid MCP server (4 strong, 1 medium validity signals). No known CVEs in dependencies. Imported from the Official MCP Registry.
Endpoint verified · Requires authentication · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Remote Plugin
No local installation needed. Your AI client connects to the remote endpoint directly.
Add this to your MCP configuration to connect:
{
"mcpServers": {
"io-neonia-cloud-os": {
"url": "https://mcp.neonia.io/mcp"
}
}
}From the project's GitHub README.
A collection of autonomous agent examples demonstrating how to integrate the Neonia Model Context Protocol (MCP) Gateway using the official Streamable HTTP transport standard.
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.
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.
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=neo_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.
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 (neo_sys_memory_note for writing and neo_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.
persistent-knowledge-memory)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 neo_sys_memory_lesson tool to save complex insights so future agents can fetch them using neo_sys_memory_search before starting their tasks.
(More examples covering vision extraction, dynamic execution, and multi-agent orchestration will be added soon!)
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:
A deterministic workflow using LangChain and LangGraph to build a reactive agent (create_agent) that dynamically wraps MCP capabilities into native LangChain @tool instances.
python/langgraph/zero-bloat-jq-filter, python/langgraph/chained-json-jq-filter, python/langgraph/auto-discovery-url-to-markdown, python/langgraph/stateful-cloud-memory, python/langgraph/persistent-knowledge-memoryuv sync && uv run python agent.pyA 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.
python/smolagents/zero-bloat-jq-filter, python/smolagents/chained-json-jq-filter, python/smolagents/auto-discovery-url-to-markdown, python/smolagents/stateful-cloud-memory, python/smolagents/persistent-knowledge-memoryuv sync && uv run python main.pyAn 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.
typescript/vercel-ai-sdk/zero-bloat-jq-filter, typescript/vercel-ai-sdk/chained-json-jq-filter, typescript/vercel-ai-sdk/auto-discovery-url-to-markdown, typescript/vercel-ai-sdk/stateful-cloud-memory, typescript/vercel-ai-sdk/persistent-knowledge-memorynpm install && npm startA 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.
rust/rig/zero-bloat-jq-filter, rust/rig/chained-json-jq-filter, rust/rig/auto-discovery-url-to-markdown, rust/rig/stateful-cloud-memory, rust/rig/persistent-knowledge-memorycargo runTo run these examples, you will need:
NEONIA_API_KEY)OPENROUTER_API_KEY)Configure these in the .env file within the specific example directory you wish to run.
agent-mcp-examples/
├── typescript/ # TypeScript Ecosystem
│ └── vercel-ai-sdk/ # Vercel AI SDK Framework
│ ├── zero-bloat-jq-filter/ # Single-tool Data Processing
│ ├── chained-json-jq-filter/ # Multi-tool Chained Data Processing
│ ├── auto-discovery-url-to-markdown/ # Auto-Pilot Tool Discovery
│ ├── stateful-cloud-memory/ # System Memory Note Persistence
│ └── persistent-knowledge-memory/ # Architectural Lesson Persistence
│
├── python/ # Python Ecosystem
│ ├── langgraph/ # LangGraph Framework
│ │ ├── zero-bloat-jq-filter/
│ │ ├── chained-json-jq-filter/
│ │ ├── auto-discovery-url-to-markdown/
│ │ ├── stateful-cloud-memory/
│ │ └── persistent-knowledge-memory/
│ └── smolagents/ # SmolAgents Framework
│ ├── zero-bloat-jq-filter/
│ ├── chained-json-jq-filter/
│ ├── auto-discovery-url-to-markdown/
│ ├── stateful-cloud-memory/
│ └── persistent-knowledge-memory/
│
└── rust/ # Rust Ecosystem
└── rig/ # Rig Framework
├── zero-bloat-jq-filter/
├── chained-json-jq-filter/
├── auto-discovery-url-to-markdown/
├── stateful-cloud-memory/
└── persistent-knowledge-memory/
Each example is self-contained and demonstrates specific, production-ready architectural patterns over MCP.
auto-discovery-url-to-markdown)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.
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.
chained-json-jq-filter)Demonstrates how to safely process massive API payloads using a chained data workflow. The agent uses neo_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 (neo_data_jq_filter) to extract exactly what it needs, keeping its context window incredibly small.
stateful-cloud-memory)Demonstrates how to use the Dual Memory Architecture (neo_sys_memory_note and neo_sys_memory_search) to allow an agent to remember personas or business rules across completely isolated sessions.
persistent-knowledge-memory)Demonstrates how to use the Dual Memory Architecture (neo_sys_memory_lesson and neo_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.
To run the examples, you will need an Anthropic API key (for the AI agent) and a free Neonia API key (for the Wasm MCP Gateway).
Clone the repository:
git clone https://github.com/neonia-io/agent-mcp-examples.git
cd agent-mcp-examples
Navigate to the example you want to try:
cd typescript/vercel-ai-sdk/zero-bloat-jq-filter
Set up environment variables:
OPENROUTER_API_KEY="your-openrouter-key"
NEONIA_API_KEY="your-neonia-key"
(Note: The Neonia Gateway requires a free API key to authenticate MCP connections).
Install dependencies and run:
npm install
npx tsx index.ts
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
by mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.