#NET

Structured business info (address, hours, services, payment methods, languages, insurance) for any named business — combines OpenStreetMap + KVK Handelsregister + LLM-extracted website data.

Enterprise-grade MCP server for automated SOCKS5 proxy pool orchestration and dynamic SMTP port 25 connectivity analytics.

cityparity gives AI agents real cost-of-living and quality-of-life comparison tools. Point it at two cities and it returns take-home pay, a full cost breakdown (housing, healthcare, childcare, food, transit, travel home, property tax), and the equivalent salary you'd need in the target city to come out even. It also surfaces the non-cash deltas people actually move for: vacation days, parental leave, universal healthcare. Beyond two-city compares, it ranks cities by a composite quality score and looks up inbound-worker tax regimes (Italy impatriati, Portugal IFICI, and a few others). Over 165 cities across 69 countries. Free, no API key, hosted Streamable HTTP.

Exposes 280+ free dev/security tools from onlinecybertools.com as MCP tools in one server: Base64/URL/JWT encoders, MD5/SHA/HMAC/bcrypt/argon2 hashes, JSON/YAML/XML formatters, regex tester, network diagnostics (ping/traceroute/dig/whois/SSL/SPF/DMARC), and OSINT lookups. No auth, no API key.

MCP server for YAML: validate & lint, convert between 10 formats, visualize as diagrams, and create/edit your saved diagrams — from your AI editor.

Your professional network in Claude — search contacts, log notes, see introductions in flight, and draft + send warm intros from your own Gmail. OAuth 2.0 with DCR; per-user account.

An MIT-licensed MCP server that gives AI agents (Claude, Cursor, Copilot) interactive .NET debugging via netcoredbg and the Debug Adapter Protocol. 26 tools: launch/attach, breakpoints (line, function, exception, data), stepping, thread inspection, stack traces, expression evaluation, variable mutation, exception autopsy, hang/deadlock analysis, server-side request tracing, and process output capture.

Where can I watch X in Y? Answer that question, in your AI assistant, for 30 Asian and Middle Eastern streaming markets. Wraps ottasia.com so the same data that powers our website is one prompt away. 3 tools: where_to_watch (specific title in a country), whats_new_on (latest arrivals on Netflix / Disney+ Hotstar / Wavve / Shahid / Hoichoi / ZEE5 / Viu / 17 more), search_titles (multi-result lookup for disambiguation). No API key required for end users.

Remote MCP server for Japan's EDINET DB — structured financial data, HR/diversity disclosures, policy shareholdings, supply chain, corporate history, and director profiles for approximately 3,800 Japanese listed companies. OAuth 2.0 multi-tenant SaaS, in production since 2026-03-01 with 5,000+ authenticated users. Considered the first remote MCP service for Japanese listed-company filings (by author's research as of 2026-02 month-end). Data sources: EDINET (FSA Japan), gBizINFO (METI), National Tax Agency corporate registry, Wikidata. Persona-specific sub-endpoints (/profile, /workforce, /governance-summary, /disclosures) and token-efficient text retrieval (/text-blocks?sections=) for LLM agents. Free tier 100 req/day, Pro from 4,980 JPY/month, Academy free for accredited researchers.

Production-grade MCP server for MikroTik RouterOS that enables AI agents and MCP-compatible clients like Claude, Cursor, and Codex to securely inspect, troubleshoot, audit, and automate RouterOS environments using natural language.

Securely search your LinkedIn network and conversations to find warm leads, intros, partners, candidates, and opportunities.

Real-time DNS, SSL, IP geolocation, blacklist check, web security scanner and 15 more network diagnostic tools for AI assistants

MCP server for LS Securities OpenAPI — Korean stock quotes, multi-timeframe charts, technical indicators, market screeners, ETF holdings, and local portfolio notes as natural-language tools for Claude Desktop, Claude Code, VS Code, and Codex. Built on .NET, distributed via NuGet as a dnx tool.

README.md--- license: apache-2.0 language: - en tags: - mcp-server - ai-gateway - security - rust - agent-framework - tool-enforcement - lmdb - rag - transformer - mesh-network - voice - android - termux - self-hosted - ai-safety - memory-system - flint - build-anchor - complexity-formula - agent-memory - p2p - quic - heed - self-learning - harness - ai-memory - persistent-memory - online-learning - agent-tools - tool-gateway - web-automation - browser-automation - social-media - p2p-communication - voice-synthesis - tts - embedded-database - zero-copy - code-search - filesystem - git - database pipeline_tag: text-generation --- ``` _____ _____ ______ _____ __ __ _____ _______ _____ _______ ______ / ____| __ \| ____| / ____| \/ | /\ | __ \__ __| / ____| /\|__ __| ____| | (___ | |__) | |__ | (___ | \ / | / \ | |__) | | | | | __ / \ | | | |__ \___ \| ___/| __| \___ \| |\/| | / /\ \ | _ / | | | | |_ | / /\ \ | | | __| ____) | | | | ____) | | | |/ ____ \| | \ \ | | | |__| |/ ____ \| | | |____ |_____/|_| |_| |_____/|_| |_/_/ \_\_| \_\ |_| \_____/_/ \_\_| |______| ``` # SPF Smart Gateway v3.0.0 **MCP Server Gateway with Multi-Layer Security Enforcement, Agent Memory, FLINT Transformer, Mesh Network, and 81 Gated Tools** > **NOTE: Full system upload still in progress.** Not all files are present yet. Repository is actively being populated — some modules may be missing until upload completes. Copyright (C) 2026 Joseph Stone — All Rights Reserved --- ## Quick Start ```bash # Clone into home folder git clone <repo-url> ~/SPFsmartGATE # Or for clones/SWARMagents: # ~/SWARMagents/1/SPFsmartGATE cd SPFsmartGATE cargo build --release # Copy optimized binary cp ~/SPFsmartGATE/target/release/spf-smart-gate ~/SPFsmartGATE/LIVE/BIN/spf-smart-gate # Configure MCP server filepath nano ~/SPFsmartGATE/LIVE/LMDB5/.mcp.json # Install Claude CLI in project directory # Use included configs, deny native Claude CLI tools # ~/SPFsmartGATE/LIVE/LMDB5/.claude.json # ~/SPFsmartGATE/LIVE/LMDB5/.claude/settings.json # Boot into flat-file agent runtime cd ~/SPFsmartGATE/LIVE/LMDB5 && claude # Boot into LMDB-backed agent runtime cd ~/SPFsmartGATE/LIVE/LMDB5.DB && claude ``` ### Route Other Models Through Claude CLI Adjust `~/SPFsmartGATE/LIVE/LMDB5/.claude/settings.local.json` with your model choice and API key. Uses OpenRouter for API and agent selection. Swap agents without changing sessions or losing project data. ### Build Notes - Cross-compiles on **Android** and **Linux** with minimal installation - Only rebuild on first boot or after system modifications - Binary: `~/SPFsmartGATE/LIVE/BIN/spf-smart-gate/spf-smart-gate` --- ## Overview SPF Smart Gateway is a **Rust-based MCP (Model Context Protocol) server** that acts as a security gateway for AI tool calls. Every file operation, bash command, brain query, and mesh call routes through compiled Rust enforcement logic. **No AI hallucination gets past the gate.** ### Web Agent Feature SPF agents can directly interact with the web and social media platforms through `spf_web_api` — a full HTTP client supporting GET, POST, PUT, DELETE, PATCH with custom headers and JSON body. Tested and working. **What agents can do:** - Post to X/Twitter, Facebook, Instagram, Reddit via their APIs - Reply to comments, send messages, manage accounts - Make authenticated API calls to any platform with stored API keys - Search, fetch, and download web content All web API calls pass through the 6-step gate pipeline with rate limiting (30-120 calls/min), content inspection, and full audit logging. Agents never touch the open web unmonitored. ### Why Heed + LMDB All persistent storage — config, agent state, brain vectors, session logs, gate training data — runs through **[heed](https://github.com/meilisearch/heed)**, a safe Rust wrapper over LMDB. This is what makes SPF extremely fast with a low memory footprint: - **Zero-copy reads** — heed maps LMDB pages directly into memory, no serialization overhead - **No server process** — LMDB is a memory-mapped B-tree library, not a database daemon - **ACID transactions** — single-writer, multi-reader with no lock contention on reads - **Sub-millisecond lookups** — B-tree index, not hash scanning - **Tiny footprint** — entire 138K+ memory store runs in-process with minimal RAM - **Phone-friendly** — designed for Android from day one; heed compiles cleanly on ARM64 Every tool call, brain search, and memory promotion goes through heed → LMDB. No network hops, no subprocess calls, no SQL parsing. The gate, brain, agent state, and FLINT training all share the same embedded database engine. Two agent runtimes: - **Flat files** — `LIVE/LMDB5/` (session state in markdown) - **LMDB database** — `LIVE/LMDB5.DB/` (session state in LMDB for persistence) Twin folder architecture: flat-file data uploaded via SPF CLI fs tools (user-only access). All agent tool calls are gated, validated, and audited. --- ## Architecture ``` ┌─────────────────────────────────────────────────────────────────┐ │ SPF Smart Gateway v3.0.0 │ │ 42 Rust modules │ ├─────────────────────────────────────────────────────────────────┤ │ MCP Server (JSON-RPC 2.0 over stdio) │ │ 81 tools │ tool alias map │ Qwen/LLM compatibility │ ├─────────────────────────────────────────────────────────────────┤ │ GATE (6-Step Pipeline) │ │ Step 0: Source logging │ │ Step 1: Rate limiting │ │ Step 2: Complexity calculation (SPF formula) │ │ Step 3: Validation (per-tool: paths, commands, Build Anchor) │ │ Step 4: Content inspection (credentials, injection) │ │ Step 5: Max mode escalation │ ├──────────┬──────────┬──────────┬──────────┬─────────────────────┤ │ FLINT │ Brain │ Mesh │ Voice │ Browser/RAG │ │ (encoder-│ (vectors │ (P2P QUIC│ (TTS/STT │ (reverse proxy │ │ decoder │ LMDB + │ Ed25519 │ espeak- │ search, fetch, │ │ ~5M │ MiniLM) │ iroh) │ ng FFI) │ RSS, web tools) │ │ params) │ │ │ │ │ ├──────────┴──────────┴──────────┴──────────┴─────────────────────┤ │ LMDB Storage Layer (heed) │ │ SPF_CONFIG │ TMP_DB │ AGENT_STATE │ Brain │ Gate Training │ │ All zero-copy reads via heed safe Rust bindings │ └─────────────────────────────────────────────────────────────────┘ ``` ### Module Inventory (42 modules) `paths`, `calculate`, `config`, `gate`, `inspect`, `mcp`, `session`, `storage`, `validate`, `web`, `http`, `dispatch`, `identity`, `mesh`, `fs`, `config_db`, `tmp_db`, `agent_state`, `tensor`, `tokenizer`, `framing`, `attention`, `ffn`, `encoder`, `decoder`, `transformer`, `checkpoint`, `gate_training`, `transformer_tools`, `train`, `learning`, `pipeline`, `worker`, `network`, `chat`, `voice`, `utf8_safe`, `brain_local`, `flint_memory`, `browser`, `orchestrator`, `channel` --- ## The SPF Formula ### Complexity Calculation ``` C = (basic ^ 1) + (dependencies ^ 7) + (complex ^ 10) + (files × 10) ``` ### Dynamic Analysis Allocation ``` a_optimal(C) = W_eff × (1 - 1/ln(C + e)) ``` Where `W_eff = 40,000` tokens and `e = Euler's number` ### Tier Allocation | Tier | C Range | Analyze | Build | Verify Passes | Approval | |------|---------|---------|-------|---------------|----------| | SIMPLE | < 500 | 40% | 60% | 1 | No | | LIGHT | < 2,000 | 60% | 40% | 1 | No | | MEDIUM | < 10,000 | 75% | 25% | 2 | No | | CRITICAL | > 10,000 | 95% | 5% | 3 | **Required** | ### Master Equation (Subtask Success) ``` P(success) = 1 - PRODUCT(1 - P_i) for i=1..D subtasks P_i = Q(a) × L(m) × V(v) × B(b) Q(a) = 1 - e^(-0.00004 × a) — Quality from analysis depth L(m) = 1 - 0.20^(m/2000) — Lookup from external memory V(v) = 1 - (1 - 0.75)^v — Verification accuracy B(b) = checks_done / checks_required — Build Anchor compliance ``` --- ## Security ### Gate Enforcement (6 Steps) Every tool call passes through `gate::process()` — compiled Rust, no runtime bypass. | Step | What | How | |------|------|-----| | 0 | Source logging | Identifies caller (Stdio, Transformer, Mesh, HTTP) | | 1 | Rate limiting | Per-tool limits (30–120 calls/min) | | 2 | Complexity calc | SPF formula → C value, tier, allocation | | 3 | Validation | Per-tool validator (paths, commands, anchors) | | 4 | Content inspection | Credential patterns, shell injection, path traversal | | 5 | Max mode | Escalation to CRITICAL tier on warnings | ### Build Anchor Protocol Files must be **read before they can be edited or overwritten**. Prevents AI hallucinations from blindly modifying files without understanding contents. - `Read` tracks files in `session.files_read` - `Edit` and `Write` check against this list - `Bash` write-class commands check target file reads - Violations: blocked (Max mode) or warned (Soft mode) ### Content Inspection Scans written/stored content for: - **Credential patterns**: API keys (sk-), AWS keys (AKIA), GitHub tokens (ghp_), Slack tokens, private keys, hardcoded passwords - **Shell injection**: Command substitution `$()`, backticks, eval/exec - **Path traversal**: `../` sequences - **Blocked path references**: Content mentioning system paths ### Blocked Paths Default blocked: `/tmp`, `/etc`, `/usr`, `/system`, `/data/data/com.termux/files/usr` ### Command Whitelist (Stage 0) Bash commands checked against sandbox and user-filesystem whitelists. Each command segment validated independently. Destructive commands (rm, chmod 777) blocked even if whitelisted. ### Default Deny Unknown tools blocked until explicitly added to the gate allowlist. --- ## MCP Tools (81 Total) ### Core Gate Tools | Tool | Description | |------|-------------| | `spf_calculate` | Calculate complexity score without executing. Returns C value, tier, allocation | | `spf_status` | Gateway status: session metrics, enforcement mode, complexity budget | | `spf_session` | Full session state: files read/written, action history, anchor ratio | ### Gated File Operations | Tool | Description | |------|-------------| | `Read` | Gated file read. Tracks for Build Anchor Protocol. Binary-safe | | `Write` | Gated file write. Validates Build Anchor, blocked paths, file size | | `Edit` | Gated file edit. Validates Build Anchor, blocked paths, change size | | `Bash` | Gated bash execution. Validates dangerous commands, /tmp access, git force | | `Glob` | Fast file pattern matching. Supports `**/*.rs`, `src/**/*.ts` | | `Grep` | Search file contents using regex. Built on ripgrep | ### Brain / Memory Tools | Tool | Description | |------|-------------| | `spf_brain_search` | Semantic vector search across collections (MiniLM-L6-v2, 384d) | | `spf_brain_recall` | Full document retrieval by semantic query | | `spf_brain_context` | Bounded context retrieval for prompt injection | | `spf_brain_store` | Store document in brain (FLINT-internal, source-gated) | | `spf_flint_store` | Agent memory store — bypasses brain write gate. Brain vectors + Working tier | | `spf_brain_index` | Index a file or directory into a brain collection | | `spf_brain_list` | List all indexed collections with document counts | | `spf_brain_status` | Brain system status: model state, storage size, collections | | `spf_brain_list_docs` | List stored documents in a collection | | `spf_brain_get_doc` | Retrieve a specific document by ID | ### Agent State Tools | Tool | Description | |------|-------------| | `spf_agent_stats` | AGENT_STATE LMDB statistics: memory count, sessions, state keys, tags | | `spf_agent_memory_search` | Search agent memories by content | | `spf_agent_memory_by_tag` | Get agent memories by tag | | `spf_agent_session_info` | Most recent session info | | `spf_agent_context` | Context summary for session continuity | ### FLINT Transformer Tools | Tool | Description | |------|-------------| | `spf_transformer_status` | FLINT transformer status: loaded, params, checkpoint, role | | `spf_transformer_infer` | Run inference: prompt → response. Returns generated tokens | | `spf_transformer_chat` | Multi-turn conversation with FLINT | | `spf_transformer_train` | Trigger manual training batch from accumulated gate signals | | `spf_transformer_metrics` | Learning metrics: loss, accuracy, gate alignment, training step | | `spf_flint_train_evil` | Mark a tool call as evil/harmful. Negative training signal | | `spf_flint_train_good` | Mark a tool call as good/safe. Positive training signal | | `spf_flint_execute` | Execute any SPF tool through FLINT worker mode (delegation) | ### Web Browser Tools **API tools (tested):** | Tool | Description | |------|-------------| | `spf_web_search` | Search the web (Brave API or DuckDuckGo) | | `spf_web_fetch` | Fetch URL and return clean readable text | | `spf_web_api` | Make HTTP API requests (GET/POST/PUT/DELETE/PATCH). Supports custom headers and JSON body — agents can directly interact with social media APIs (X/Twitter, Facebook, Instagram, Reddit, etc.) using stored API keys | | `spf_web_download` | Download a file from URL and save to disk | **Browser automation tools (in development — proxy starts, WebSocket bridge needs browser connection):** | Tool | Description | Status | |------|-------------|--------| | `spf_web_connect` | Initialize reverse proxy browser engine | Tested — works | | `spf_web_navigate` | Navigate browser to a URL (SSRF-validated) | Tested — works | | `spf_web_click` | Click a page element by CSS selector | In development — WebSocket timeout | | `spf_web_fill` | Type text into a form field by CSS selector | In development — WebSocket timeout | | `spf_web_select` | Query page elements by CSS selector | In development — WebSocket timeout | | `spf_web_eval` | Execute JavaScript on the current page | In development — WebSocket timeout | | `spf_web_screenshot` | Capture a screenshot of the current page | In development | | `spf_web_design` | Extract design brief: colours, fonts, spacing, components | In development | | `spf_web_page` | Structured page overview: title, headings, links, forms | In development | ### RAG Collector Tools | Tool | Description | |------|-------------| | `spf_rag_collect_web` | Search web and collect documents. Optional topic filter | | `spf_rag_collect_file` | Process a local file into brain | | `spf_rag_collect_folder` | Process all files in a folder | | `spf_rag_collect_drop` | Process files in DROP_HERE folder | | `spf_rag_index_gathered` | Index all documents in GATHERED to brain | | `spf_rag_dedupe` | Deduplicate a brain collection | | `spf_rag_status` | Collector status and stats | | `spf_rag_list_gathered` | List documents in GATHERED folder | | `spf_rag_bandwidth_status` | Bandwidth usage stats and limits | | `spf_rag_fetch_url` | Fetch a single URL with bandwidth limiting | | `spf_rag_collect_rss` | Collect from RSS/Atom feeds | | `spf_rag_list_feeds` | List configured RSS feeds | | `spf_rag_pending_searches` | Get pending SearchSeeker vectors (gaps needing fetch) | | `spf_rag_fulfill_search` | Mark a SearchSeeker as fulfilled after RAG fetch | | `spf_rag_smart_search` | Smart search with completeness check — triggers SearchSeeker if <80% | | `spf_rag_auto_fetch_gaps` | Automatically fetch data for all pending SearchSeekers | ### Mesh Network Tools | Tool | Description | |------|-------------| | `spf_mesh_status` | Mesh network status: role, team, identity | | `spf_mesh_peers` | List known/trusted mesh peers | | `spf_mesh_call` | Call a peer agent's tool via P2P mesh (Ed25519 authenticated) | ### Voice Tools | Tool | Description | |------|-------------| | `spf_voice_mode` | Voice pipeline control: start/stop audio, TTS (espeak-ng), mic capture | | `spf_voice_call` | Peer-to-peer voice calls: start, accept, reject, end, status | | `spf_voice_team` | Group voice channels: create, join, leave, add peers | ### Chat Tools | Tool | Description | |------|-------------| | `spf_chat_send` | Send text message to mesh peer via QUIC | | `spf_chat_history` | Chat message history (all conversations or specific) | | `spf_chat_rooms` | List active chat conversations with participant info | ### Network Pool Tools | Tool | Description | |------|-------------| | `spf_pool_status` | Pool status: worker roles, idle/busy counts, active tasks | | `spf_pool_assign` | Assign task to idle worker (NetAdmin only) | | `spf_pool_release` | Release worker and record proof of work receipt | ### Configuration Tools | Tool | Description | |------|-------------| | `spf_config_paths` | List all path rules (allowed/blocked) from SPF_CONFIG | | `spf_config_stats` | SPF_CONFIG LMDB statistics | ### Project Management Tools | Tool | Description | |------|-------------| | `spf_tmp_list` | List all registered projects with trust levels | | `spf_tmp_stats` | TMP_DB statistics: project count, access logs, resources | | `spf_tmp_get` | Get project info by path | | `spf_tmp_active` | Get the currently active project | ### Communication Hub | Tool | Description | |------|-------------| | `spf_channel` | Universal agent channel: create, join, leave, send, listen, history, list, connect (WS), disconnect, status | ### Notebook Tools | Tool | Description | |------|-------------| | `spf_notebook_edit` | Edit a Jupyter notebook cell (replace, insert, delete) | ### User-Only Tools (AI agents blocked) These tools are **hard-blocked** from AI agents at the gate level. User/system access only via SPF CLI: `spf_fs_exists`, `spf_fs_stat`, `spf_fs_ls`, `spf_fs_read`, `spf_fs_write`, `spf_fs_mkdir`, `spf_fs_rm`, `spf_fs_rename` --- ## FLINT Transformer Built-in encoder-decoder transformer for gate-aligned learning. | Property | Value | |----------|-------| | Architecture | Encoder-decoder | | Dimensions | 256d | | Heads | 8 | | Layers | 6 | | Parameters | ~5M | | Embeddings | all-MiniLM-L6-v2 (384d, in-process) | | Online learning | ON | | EWC lambda | 0.4 | | Learning rate | 1e-4 | | Replay buffer | 10,000 slots | | Checkpoint interval | 1,000 steps | | Training signal | Gate decisions (evil/FP labels) | ### Learning Pipeline | Phase | When | What | |-------|------|------| | PRE | Startup | init_brain() + index_knowledge_docs() + index_spf_sources() | | DURING | 30s loop | GateTrainingCollector → FLINT scores → route_signals → brain_store() | | AFTER | 1hr loop | Expire → Working→Fact → Fact→Pinned → auto-train (16+ tlog or 1hr) | ### Memory Lifecycle (Tiered Promotion) ``` Agent stores → Working (24hr) → Fact (7-day) → Pinned (permanent) ↓ ↓ ↓ Expire old Top 20% promote Never auto-expire ``` --- ## Brain System In-process vector memory using stoneshell-brain (Candle + LMDB + MiniLM-L6-v2). | Property | Value | |----------|-------| | Model | all-MiniLM-L6-v2 | | Embedding dim | 384 | | Chunk size | 512 | | Chunk overlap | 64 | | Storage | LMDB (vectors) + LIVE/BRAIN/DOCS/ (data files) | ### Collections | Collection | Purpose | |------------|---------| | `default` | General knowledge, web research, project docs | | `spf_source` | All src/*.rs modules indexed at boot | | `flint_results` | Tool call results (>2000 chars, before compression) | | `flint_training` | Gate decision signals, evil/FP labels | | `flint_knowledge` | User-dropped knowledge files (.md/.txt/.rs/.json) | | `flint_episodic` | Past FLINT Q+A pairs, behavioral patterns | | `session_state` | Current session metadata | ### Memory Triad (Redundant Persistence) Three systems — if any ONE fails, the other TWO recover: 1. **Brain** (vectors) — Semantic search, chunked knowledge 2. **STATUS** (sequential) — Current state, phase, next step 3. **Work Blocks** (structural) — Tasks, dependencies, confidence, progress 4. **Twin Folders** (evidence) — Data served for low-confidence work blocks --- ## Mesh Network P2P agent communication over QUIC (iroh library) with Ed25519 identity. **In development and testing.** | Feature | Status | |---------|--------| | P2P QUIC transport | In development | | Ed25519 identity | In development | | Peer discovery | In development | | Tool call proxying | In development | | Voice over mesh | In development | | Chat over mesh | In development | | Multi-agent coordination | In development | --- ## Voice Pipeline **Not yet tested.** Components built, awaiting integration testing. | Component | Technology | |-----------|-----------| | TTS | espeak-ng FFI (in-process) | | Codec | Opus (libopus.a) | | Audio | cpal + oboe-ext | | STT | Pending (JNI via Stone Shell Terminal) | --- ## Result Compression (FL-2) Three tiers based on result size: | Tier | Size | Behavior | |------|------|----------| | FULL | < 500 chars | Pass through unchanged | | SUMMARY | 500–5,000 | First 8 lines + last 3 lines + stats | | DIGEST | > 5,000 | First 200 chars + last 100 chars + stats + recall hint | Originals always preserved in brain (>2000 chars threshold) before compression. File reads never truncated (preserves non-Claude LLM compatibility). --- ## Build ```bash cd SPFsmartGATE cargo build --release # Deploy binary cp target/release/spf-smart-gate LIVE/BIN/spf-smart-gate/spf-smart-gate ``` ### Dependencies - Rust (stable) - **[heed](https://github.com/meilisearch/heed)** — safe Rust LMDB bindings. All persistent storage (config, agent state, brain vectors, training data) runs through heed → LMDB. Zero-copy reads, no server process, sub-millisecond lookups. The core reason SPF runs fast on a phone. - stoneshell-brain (Candle + MiniLM-L6-v2) - espeak-ng (TTS) - libopus (audio codec) - iroh (QUIC mesh) --- ## Configuration ### MCP Server Config `~/SPFsmartGATE/LIVE/LMDB5/.mcp.json` — points Claude CLI to the binary. ### Claude CLI Config `~/SPFsmartGATE/LIVE/LMDB5/.claude.json` — blocks native Claude CLI tools (26 tools denied). `~/SPFsmartGATE/LIVE/LMDB5/.claude/settings.json` — deny list for native tools. `~/SPFsmartGATE/LIVE/LMDB5/.claude/settings.local.json` — model routing (OpenRouter). ### SPF Config Enforcement mode (`soft` or `max`), blocked paths, allowed paths, formula weights — all in LMDB SPF_CONFIG database. --- ## File Structure ``` SPFsmartGATE/ ├── Cargo.toml # Rust project manifest (42 modules) ├── LICENSE # Apache-2.0 ├── README.md # This file ├── src/ │ ├── main.rs # CLI entry point │ ├── lib.rs # Library exports (42 pub mod) │ ├── gate.rs # Primary enforcement (6-step pipeline) │ ├── calculate.rs # SPF complexity formula │ ├── validate.rs # Rules validation (stages 0-6) │ ├── inspect.rs # Content inspection (creds, injection) │ ├── mcp.rs # MCP server (JSON-RPC 2.0, 81 tools) │ ├── dispatch.rs # Unified dispatch (all transports) │ ├── session.rs # Session state management │ ├── storage.rs # LMDB persistence │ ├── config.rs # Configuration types │ ├── brain_local.rs # In-process brain singleton │ ├── flint_memory.rs # Memory router + tiered promotion │ ├── agent_state.rs # Agent memory (LMDB5) │ ├── transformer.rs # FLINT model (encoder-decoder) │ ├── transformer_tools.rs # FLINT tool handlers │ ├── gate_training.rs # Training signal collection │ ├── train.rs # AdamW optimizer │ ├── tokenizer.rs # Tokenizer │ ├── tensor.rs # Tensor operations │ ├── attention.rs # Multi-head attention │ ├── ffn.rs # Feed-forward network │ ├── encoder.rs # Encoder stack │ ├── decoder.rs # Decoder stack │ ├── framing.rs # Message framing │ ├── checkpoint.rs # Model checkpoint save/load │ ├── learning.rs # Learning rate + EWC │ ├── pipeline.rs # Batch pipeline + API sessions │ ├── worker.rs # Worker pool │ ├── network.rs # Network pool + NetAdmin │ ├── mesh.rs # P2P QUIC mesh (iroh) │ ├── identity.rs # Ed25519 identity │ ├── chat.rs # Chat engine │ ├── voice.rs # Voice pipeline (TTS/STT) │ ├── web.rs # Web client │ ├── http.rs # HTTP server + reverse proxy │ ├── browser.rs # Browser automation │ ├── channel.rs # Universal channel hub │ ├── orchestrator.rs # Multi-agent orchestrator │ ├── config_db.rs # SPF_CONFIG LMDB │ ├── tmp_db.rs # TMP_DB LMDB │ ├── fs.rs # Virtual filesystem (LMDB) │ ├── paths.rs # Path utilities │ └── utf8_safe.rs # UTF-8 safe truncation ├── LIVE/ │ ├── BIN/spf-smart-gate/ # Deployed binary │ ├── BRAIN/DOCS/ # Brain data files │ ├── MODELS/ # FLINT checkpoints │ ├── SESSION/ # Session logs │ ├── LMDB5/ # Flat-file agent runtime │ └── LMDB5.DB/ # LMDB-backed agent runtime └── PROJECTS/PROJECTS/ └── DEPLOY/ # Agent workspace ``` --- ## Current Status | Component | Status | |-----------|--------| | MCP Server | 81 gated tools | | Gate Security | 6-step pipeline, compiled Rust enforcement | | Build Anchor | Read-before-write enforced | | Content Inspection | Credential + injection scanning | | FLINT Transformer | ~5M params, online learning, gate-aligned | | Brain | 7 collections, MiniLM-L6-v2, in-process | | Memory Triad | Brain + STATUS + Work Blocks + Twin Folders | | Tiered Promotion | Working → Fact → Pinned lifecycle | | Mesh Network | P2P QUIC, Ed25519, iroh — **in development and testing** | | Voice | TTS built (espeak-ng) — **not yet tested**, STT pending | | Chat | P2P messaging over mesh — **in development** | | RAG | Web search, RSS, file/folder indexing | | Web Agent | **Working** — spf_web_api tested (GET/POST with auth headers). Agents can interact with social media APIs | | Browser | API tools working (web_api, search, fetch). Browser automation (navigate/click/fill/select/eval) in development — proxy starts but WebSocket bridge needs browser connection | | Network Pool | Worker pool with proof of work | --- ## Notes - **1 developer** — not all features complete - **Gateway security**: approaching 100% - **All core tools**: 100% working - **Cross-compiles** on Android and Linux with minimal installation - **Agent cloning and specialization** supported - **50+ day continuous session** tested on Android phone - **Open source** — entire source code refreshes into transformer RAG system every reboot - Install in home folder, ensure file paths are correct in `.mcp.json` and `settings.local.json` - **Not all files have been uploaded yet** — repository is still being populated. Some modules may not be present until upload completes. --- ## License Licensed under the **Apache License 2.0**. See [LICENSE](LICENSE) for full terms. You are free to use, modify, and distribute this software, including for commercial purposes, provided you include the original copyright and license notice. **Author**: Joseph Stone **Email**: joepcstone@gmail.com *SPF (StoneCell Processing Formula), Build Anchor Protocol, and FLINT are proprietary designs of Joseph Stone.*

Open-source, self-hostable MCP server for WhisperGraph — a graph of 7.39B nodes / 39B edges mapping DNS, BGP, GeoIP, WHOIS, and threat intelligence. Six read-only tools (Cypher query + schema introspection + threat assessment), six resources, eight investigation prompts. stdio and Streamable HTTP transports.

AI-powered documentation health monitor — detects stale doc comments and suggests updates using Claude. Works as an MCP server for Claude Desktop, Claude Code, and GitHub Copilot.

The internet's largest queryable infrastructure graph — 7.39 billion nodes, 39 billion edges, 5.6 million threat-intelligence relationships. Pivot from any IP, domain, or ASN across DNS, BGP, WHOIS, GeoIP, and threat intel in a single Cypher query. Most threat-intel and OSINT APIs are point lookups: you ask about one indicator, you get one record. Investigations don't work that way — you start from one suspicious domain and need to trace its hosting, its sibling domains, its registrar, its email infrastructure, the ASN announcing its IP, and which feeds have flagged anything nearby. WhisperGraph stores all of that as a single connected graph and lets you traverse it natively. One query can answer questions that would take dozens of API calls anywhere else. Example questions you can ask **Is xyz-uknown@suspicious.com a safe email address? **What is the IP address of whisper.security? "What's the threat reputation of 45.142.213.55, and what feeds flagged it?" "Show every domain sharing this domain's MX records and registrant email." "Map the full DNS and BGP attack surface of example.com." "Which ASNs in Russia have the highest concentration of phishing-flagged IPs this quarter?" "Find all domains registered within 24 hours of suspicious-domain.com using the same registrar." "What's the historical WHOIS for disputed-domain.com going back 5 years?" "Which prefixes does AS13335 currently announce, and were any of them previously announced by a different ASN?"

Kubernetes cluster cost analysis and optimization. Query costs, find savings opportunities, get rightsizing recommendations, and analyze pod spend across AKS, EKS, and GKE directly from Claude.

TronSave MCP server focused on helping agents and clients buy and sell TRON resource quickly through one unified interface, with fast order execution, pricing/estimation tools, and secure session-based workflows.

Read-only MCP server for U.S. dental practice intelligence. Four tools cover NPI lookup, multi-field provider search, DSO chain affiliation, and territory market summaries across 41 states plus DC. Authenticate with an API key (Bearer) for subscription pricing, or pay per query via x402 USDC micropayments on Base mainnet. Every response carries a citation envelope with source attribution, snapshot date, and confidence score.

Lightrun MCP connects AI coding assistants to live runtime context from production and staging applications for safe code-level debugging without redeploying. It lets MCP-compatible clients discover runtime sources, inspect live expression values, capture call stacks, measure execution duration, count executions, and collect numeric runtime metrics directly from the AI workflow.

Bittensor subnet intelligence for AI agents. Mineability scores (MINE/CAUTION/AVOID) for all 128 subnets, 1-click deploy scripts for 16 subnets, momentum scoring, whale flows, institutional tracking. 18 API endpoints. Free tier, no auth required.

Coordination protocol for real-world tasks (cleaning, plumbing, painting, gardening, repair) in the Netherlands. AI agents create tasks via natural language through POST /do endpoint. AstraNL handles provider matching, transparent pricing, Stripe Connect escrow (99% to provider, 1% AstraNL fee), evidence chain, dispute resolution. Free first 3 tasks per agent. KvK 88449335, EU AI Act compliant. Supports 10 languages.

Control Mullvad VPN from any MCP-compatible AI client. Connect, disconnect, switch servers, check for leaks, manage kill switch, DAITA, multihop, DNS blocking, and more — all via the local Mullvad CLI.

Monetize your AI agent with affiliate commissions. Browse 25+ SaaS affiliate programs, generate tracked links per end user, and record conversions — all from MCP tools. Install once with npx, earn recurring revenue when your users sign up for recommended tools.

WhoisJSON MCP Server exposes four domain intelligence tools directly inside Claude, Cursor, and Windsurf — no code required. whois_lookup: Full WHOIS registration record for any domain — registrar, creation and expiry dates, nameservers, registrant contacts, and DNSSEC status. dns_lookup: All DNS records in a single call — A, AAAA, MX, TXT, CNAME, NS, SOA, CAA, DMARC, and more. Useful for mail server audits, SPF/DKIM verification, and infrastructure mapping. ssl_check: TLS certificate details including issuer, expiry date, Subject Alternative Names, and full chain validity. Detect expired or misconfigured certificates instantly. domain_availability: Instant registration availability check for any TLD. Returns a clear registered/available status. Your WhoisJSON API key works identically for the REST API and the MCP server. 1,000 free requests/month, no credit card required. Get your API key at whoisjson.com.

11 tools that help AI assistants answer budgeting questions — create budget plans, calculate net worth, financial runway, savings goals, audit subscriptions, and demo voice input. Powered by GetALife app.

MCP server for Talos Linux cluster management via the native gRPC API

EdgeDNS provides a server that exposes 90 domain intelligence tools covering DNS, email security, website security, SEO analysis, tech stack detection, performance, threat intelligence, network diagnostics, compliance, and reporting.

Security-first MCP server for TP-Link Omada, with a stdio-first runtime, capability-gated tools, and OpenAPI-based network automation.

Hosted MCP DNS utility for querying records through a paid remote server with first-call proof and x402 payment gating.

MCP server for discovering and invoking monetized AI tools. Agents connect to search the SettleGrid marketplace by keyword or category, inspect tool details and pricing, and call any tool — all through the Model Context Protocol. Supports per-call billing via Stripe Connect.

Lightning-paid tool stack for autonomous agents. Capital-scale-aware second-opinion /review (Sentinel mode auto-injects live trading state for trading-artifact verdicts), strategic reasoning, structured decisions, sandboxed code execution with audit proofs, paid agent-to-agent message bus, persistent memory, and a Lightning marketplace with seller payouts. Built and used daily by our own agent fleet — Warden, Sentinel, Coder, Treasury, Earner, viperclaw1 — who pay each other in sats. External agents get the same infrastructure on the same terms. Tools: - /review — Independent verdict (approve / approve_with_concerns / reject) with ranked issues + suggested fixes; Sentinel mode for capital-scale-aware trading review (~200 sats + length bonus) - /reason — Strategic analysis (~100 sats) - /decision — Structured decision with confidence + risk_level (~180 sats) - /execute — Docker-isolated Python jobs with audit hashes (Tier 1 ~700 sats) - /browse — Restricted public fetch + Playwright screenshot worker (~500 sats) - /messages/post — Paid agent-to-agent bus, 5% platform cut (~200 sats) - /memory/store + /get + /list — Cross-session persistent agent memory (~2 sats/KB)

The Netfluid skill provides AI agents with comprehensive banking and cryptocurrency wallet operations. It enables agents to manage fiat and crypto accounts, perform transfers, create payment bridges, and handle KYC verification — all through a unified MCP (Model Context Protocol) interface.

Safari DevTools MCP — real browser debugging with network interception, DOM inspection, cookie/storage management, and CSS analysis for AI agents on macOS

# mcp-k8s-ro A read-only MCP server that gives Claude access to Kubernetes clusters. Built in Go, communicates over stdio using the MCP protocol. ## Design - **Read-only** — only `get`, `describe`, `logs`, and `top` style operations. No create, update, or delete. If a mutating operation is needed, the server prints the equivalent `kubectl` command for you to run manually. Safe to use while on-call at night: Claude can never accidentally mutate your cluster, even under prompt fatigue. - **Secret-safe** — secret values are masked before being sent to the model, so your secrets cannot leak due to misconfiguration or prompt injection. - **Token-efficient** — responses include only relevant fields (name, status, restarts, etc.) rather than raw Kubernetes API objects, keeping context usage low. - **Cluster-aware** — every response includes the active context and cluster name, so Claude always knows which cluster it is talking to. - **Context-pinned** — the server locks to the active kubeconfig context at startup. Switching contexts in another terminal has no effect on the running server. - **No extra infra** — runs as a local binary or Docker container, connects to whatever kubeconfig context is active at startup. ## Redacted fields | Object/Field | Reason | |--------------------------------------------------------|----------------------------------------------------------| | Secret.data | Secret leak prevention | | Secret.stringData | Secret leak prevention | | CertificateSigningRequest.spec.request | Large base64 PEM blob, no diagnostic value, saves tokens | | Certificate (cert-manager) .spec.keystores | Cert chain PEM blobs, no diagnostic value, saves tokens | | Certificate (cert-manager) status.conditions[].message | Cert chain PEM blobs, no diagnostic value, saves tokens | | *.managedFields | No diagnostic value, saves tokens | ## Tools | Tool | Description | |---------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `k8s_list_resources` | List any resource type by name — pods, deployments, CRDs, etc. Accepts optional namespace filter. Returns name, status, readiness, restarts, node, IP, and more depending on resource kind. | | `k8s_describe_resource` | Return the full YAML of a single resource. Secret data is masked. | | `k8s_list_resource_types` | List all available resource types via the discovery API. Accepts optional API group filter. | | `k8s_get_logs` | Fetch pod logs. Supports container selector, tail lines, and `--previous` for crashed containers. | | `k8s_get_events` | List Kubernetes events for a namespace or the whole cluster, sorted by most recent. | | `k8s_top_pods` | CPU and memory usage per pod, with per-container breakdown. Requires metrics-server. | | `k8s_top_nodes` | CPU and memory usage per node, with percentage of allocatable capacity. Requires metrics-server. | ## Configuration | Environment variable | Default | Description | |----------------------|------------------|-------------------------| | `KUBECONFIG` | `~/.kube/config` | Path to kubeconfig file | ## Usage with Claude ### Binary Build the binary and add it to your Claude Desktop or `claude` CLI configuration: ```bash make build # binary is written to bin/mcp-k8s-ro ``` ```json { "mcpServers": { "k8s": { "type" : "stdio", "command": "/path/to/bin/mcp-k8s-ro", "env": { "KUBECONFIG": "/path/to/.kube/config" } } } } ``` Or via the CLI: ```bash claude mcp add --transport stdio --scope user mcp-k8s-ro [path to binary] ``` ### Docker Pull the image from GitHub Container Registry (pinning a specific version is recommended): ```bash docker pull ghcr.io/your-ko/mcp-k8s-ro:latest ``` Add it to your Claude Desktop or `claude` CLI configuration. The kubeconfig directory is mounted read-only into the container: ```json { "mcpServers": { "k8s": { "command": "docker", "args": [ "run", "--rm", "-i", "-v", "/path/to/.kube:/home/nonroot/.kube:ro", "ghcr.io/your-ko/mcp-k8s-ro:latest" ] } } } ``` If your kubeconfig is in a non-standard location, pass it via `KUBECONFIG`: ```json { "mcpServers": { "k8s": { "command": "docker", "args": [ "run", "--rm", "-i", "-e", "KUBECONFIG=/config/my-kubeconfig", "-v", "/path/to/my-kubeconfig:/config/my-kubeconfig:ro", "ghcr.io/your-ko/mcp-k8s-ro:latest" ] } } } ``` ## Single-cluster design The server intentionally operates on one kubeconfig context and provides no tool to switch clusters at runtime. The reasons are: - **Prompt injection isolation** — a malicious value in one cluster's resources (e.g. a pod annotation) cannot instruct Claude to pivot to a different cluster, including production. - **Explicit audit boundary** — every tool response includes the context and cluster name, so there is never ambiguity about which cluster was queried. **To point the server at a different cluster**, stop the server, switch context, and restart: ```bash kubectl config use-context my-other-cluster # then restart the MCP server / reload Claude Desktop ``` **To work with multiple clusters simultaneously**, register a separate server instance per cluster in your MCP config: ```json { "mcpServers": { "k8s-staging": { "type": "stdio", "command": "/path/to/bin/mcp-k8s-ro", "env": { "KUBECONFIG": "/path/to/.kube/config" } }, "k8s-prod": { "type": "stdio", "command": "/path/to/bin/mcp-k8s-ro", "env": { "KUBECONFIG": "/path/to/.kube/config-prod" } } } } ``` Claude will address each [.claude.json](../../.claude.json)server by name and each instance only ever sees its own cluster.

Search, hire, and pay AI agents with USDC on-chain. 7 MCP tools: browse listings, get details, pay via x402 protocol, track transactions, retry fulfillment, and check marketplace stats. Agents list services, humans (or other agents) discover and pay them — settlement happens on Arc Testnet (chain 5042002). ERC-8004 on-chain agent identity. Currently testnet only — mainnet coming soon.

Discover monetized AI tools on SettleGrid. Search by category, get pricing, find developers. 4 tools: search_tools, get_tool, list_categories, get_developer. The settlement layer for AI agent payments — free forever, 10 protocols, 1,017 templates.

Earn from your distribution or buy ad reach. picoads is an agent-native ad network with independent delivery verification and settlement in USDC on Base. Publishers: Call get_sponsored() to serve sponsored recommendations — no registration needed. Register ($1 USDC) to earn from clicks. You receive 100% of the agreed price. Advertisers: Post a bid with your creative and budget. Matching is automatic. You pay CPC (cost per click) — serves are free, you're only charged when an agent's user clicks. 20 MCP tools. CPC billing. Verified delivery. USDC settlement on Base. Connect: https://picoads.xyz/mcp (streamable-http, Bearer pico_ API key) Docs: https://picoads.xyz/llms.txt

Security testing MCP server with 51 tools across 19 modules. Covers SQL injection, XSS, command injection, SSRF, path traversal, PCAP forensics, memory forensics (Volatility), reconnaissance, malware analysis, CloudTrail analysis, and more. Includes 8 methodology prompts for guided security workflows. Run via npx operant-mcp.

Full email marketing platform for AI assistants — 32 MCP tools for campaigns, contacts, automations, A/B testing, AI subject line generation, multi-channel messaging (email + WhatsApp + push), deliverability monitoring, DMARC health checks, ecommerce revenue attribution, and advanced analytics.

Control real robots and IoT devices through AI agents. Self-register with wallet authentication, pay with ETH for tier upgrades, and execute Vision-Language-Action commands. Features robot control, sensor monitoring, multi-agent coordination, and autonomous payments.

Full email marketing platform for AI assistants — 32 MCP tools for campaigns, contacts, automations, A/B testing, AI content, multi-channel messaging (email + WhatsApp + push), deliverability monitoring, DMARC health checks, ecommerce revenue attribution, and advanced analytics.

Connect AI assistants to the Anycast network. Manage agents, send messages, control access policies, and monitor connectivity — all from Claude, Cursor, or any MCP-compatible client. 19 tools covering agent registration, P2P connections, groups, policies, and analytics.

Route tasks requiring human judgment to a vetted worker pool from any AI agent. Content moderation, refund decisions, data verification, quality assessments — when AI hits its limit, HumanRail routes to humans, verifies results, and pays workers via Lightning Network. 7 tools: create_task, get_task, wait_for_task, cancel_task, list_tasks, get_usage, health_check.

Local MCP server that gives AI agents eyes and hands on running Uno Platform apps. Agents can capture screenshots, inspect the visual tree, simulate pointer clicks, type text, send key presses, invoke automation peer actions, and query DataContext, enabling agentic UI development and testing across WebAssembly, iOS, Android, macOS, and Linux. Works with Visual Studio Copilot, VS Code, Claude Code, Codex, and any MCP-compatible agent

Cloud-hosted MCP server providing real-time Uno Platform documentation search, 26 topic routing rules, and a complete UI/UX design system. Grounds AI agents in official Uno Platform best practices for XAML, MVUX/MVVM, Material Design, responsive layouts, and .NET cross-platform development.

TurboPentest is an agentic AI penetration testing platform built by IntegSec that makes professional-grade security assessments accessible to every organization. Instead of waiting weeks for a manual pentest engagement or relying on a single scanning tool, TurboPentest deploys up to 20 autonomous AI agents that orchestrate 15 professional security tools - including Nmap, OWASP ZAP, Nuclei, Nikto2, OpenVAS, TestSSL, Subfinder, HTTPX, FFUF, Wafw00f, Gitleaks, Semgrep, Trivy, IntegSec PentestTools, and Paladin AI - in a single automated workflow. At the core is Paladin AI, an autonomous pentesting agent powered by Claude Sonnet 4.6. While Phase 1 tools gather reconnaissance data, Paladin is where the actual penetration test happens - specialist AI agents validate exploits, discover multi-step attack chains, generate proof-of-concept demonstrations, and assess business impact. This is what makes TurboPentest an agentic pentest rather than just a scanner with AI features. The result is a comprehensive security assessment that covers the OWASP Top 10, network-level vulnerabilities, TLS/SSL misconfigurations, exposed secrets, hidden endpoints, subdomain enumeration, and more. Every scan generates five professional deliverables: a detailed PDF report with severity-ranked findings and remediation guidance, a blockchain-anchored security attestation letter (Base L2) suitable for auditors, customers, and compliance frameworks like SOC 2 and ISO 27001, an attack surface map visualizing your external exposure, a STRIDE-based threat model outlining risk scenarios with prioritized manual testing recommendations, and retest commands (Docker-based) to verify remediation. Scans support both black box (external-only) and white box (with GitHub integration for source-level analysis via Gitleaks, Semgrep SAST, and Trivy SCA) modes. TurboPentest integrates directly into CI/CD pipelines through its GitHub Action, enabling security testing on every pull request or deployment. Results are typically delivered in up to 4 hours. Pricing starts at $49 per scan (Recon tier). Four tiers are available: Recon ($49, 1 agent, 30 min), Standard ($99, 4 agents, 1 hour), Deep ($299, 10 agents, 2 hours), and Blitz ($699, 20 agents, 4 hours). Volume discounts of 10-30% are available for 10+ scans, and subscription plans offer additional savings. TurboPentest is hosted on Microsoft Azure. Reports are built to meet the documentation requirements of SOC 2, ISO 27001, PCI DSS, HIPAA, and CMMC. For more information, visit https://turbopentest.com or contact support@integsec.com.

mctl is a self-service Kubernetes platform that automates infrastructure management via natural language. It integrates GitOps (ArgoCD), secrets management (Vault), and automated service onboarding into a unified set of 30+ MCP tools. Engineering teams can deploy, scale, and monitor their clusters directly from Claude, Cursor, or Gemini without manual CLI operations.

Strips PII (emails, SSNs, API keys, phone numbers, addresses) from text before agents send data to third parties. GDPR/HIPAA aligned. Stateless. Pay $0.005 USDC per scrub via x402 on Base network.

Compresses large blocks of text, code, or conversation history into hyper-dense Reasoning Maps optimized for LLM context windows. Saves agents 80%+ on token costs. Stateless. Pay $0.001 USDC per compression via x402 on Base network.

Your AI finds the right people for you. Agent-to-agent networking via MCP. Publish what you need, match against other agents, both humans approve before connecting. Ed25519 signed IntentCards, hosted API at api.aeoess.com.

100-tool browser automation for AI agents via MCP. Screenshots, DOM inspection, network capture, form filling, cookie management, tab orchestration, session recording, and structured data extraction via Chrome extension. One-command setup: npx crawlio-browser init auto-configures 14 MCP clients.recording + 1 compiler) with framework-aware intelligence, typed evidence infrastructure, and confidence-tracked findings — captures what static crawlers can't see.

eBPF-based GPU causal observability agent with MCP server. Traces CUDA Runtime/Driver APIs and host kernel events to build causal chains explaining GPU latency

Wireshark/tshark MCP server — capture live network traffic, analyze .pcap files, apply display filters, follow TCP/UDP streams, and export to JSON. Works with Claude Desktop, VS Code Copilot, and any MCP-compatible client.

MCP server for the FortiMonitor v2 monitoring API. 241 tools across 33 modules covering server management, outage monitoring, maintenance windows, metrics, notifications, cloud monitoring, SNMP, dashboards, reporting, and more. Unofficial community project, not affiliated with Fortinet. Python, MIT license, Docker and local deployment supported.

Full-stack AI marketing toolkit — scout X/Twitter and Reddit for trending topics, discover and deep-analyze competitors, find content gaps, publish SEO- and GEO-optimized articles with AI illustrations and voice-over in 55 languages, create social media adaptations for X, LinkedIn, Facebook, Reddit, Threads, Instagram, Instagram Reels, YouTube Shorts, and Shopify, generate lead magnets (checklists, swipe files, frameworks), ingest any URL (YouTube videos, web articles, PDFs, audio files) into structured content, ultra-cheap turbo articles from 2 credits, generate short-form AI avatar videos with subtitles, and run fully automated content autopilot. Powered by Citedy.

Identify plants from photos using the Pl@ntNet API. Returns ranked species matches with confidence scores, scientific/common names, and taxonomic data. 3 tools: identify_plant, list_projects, check_quota.

Give your AI assistant a packet analyzer. Drop a .pcap file, ask questions in plain English — get answers backed by real tshark data.

Monetize your MCP server with contextual ads. 70% revenue share for developers. 8 tools: search_ads, report_event, create_campaign, create_ad, get_analytics, update_campaign, list_campaigns, get_ad_guidelines.

A remote MCP server deployed on Railway that exposes all 14 Softricks iDig tools to any MCP-compatible AI client. One config entry and your AI assistant has professional DNS diagnostics available in every conversation → https://mcp.softricks.net/sse Add that to Claude Desktop or Cursor, restart, and you can ask things like: "My emails are going to spam for example.com — what's wrong?" "Did my DNS changes propagate yet?" "Is our SSL cert about to expire?" "Run a full security audit on this domain." And your AI will call live DNS infrastructure to answer.

AI training dataset marketplace — 2M+ museum artworks across 7 world-class institutions with on-demand 111-field Golden Codex AI enrichment. x402 USDC micropayments on Base L2. First monetized art/provenance MCP server. Research-backed: dense metadata improves VLM capability by +25.5% (DOI: 10.5281/zenodo.18667735) The complete creative AI pipeline exposed as MCP tools. From generation to permanent storage — every stage available via x402 USDC micropayments on Base L2. Generation - SD 3.5 Large + T5-XXL — Stable Diffusion 3.5 Large with T5-XXL text encoder on NVIDIA L4 GPU. High-fidelity image generation with superior prompt adherence. LoRA support (Artiswa v2 style transfer). Upscaling - ESRGAN x4 Upscaler — Real-ESRGAN x4plus on NVIDIA L4 GPU (24GB VRAM). Takes 1024px to 4096px in ~1.15s. Production-grade super-resolution for print and archival quality. AI Enrichment - Golden Codex Metadata Creation (Nova) — 111-field deep visual analysis powered by Gemini VLM. Color harmony, composition, symbolism, emotional journey, provenance chain, archetypal resonance. 2,000-6,000 tokens per artwork. Research-backed: +25.5% VLM improvement (DOI: 10.5281/zenodo.18667735). Metadata Infusion - Atlas XMP/IPTC/C2PA Infusion — Embed Golden Codex metadata directly into image files via ExifTool. XMP-gc namespace, gzip+base64 compressed payload, SHA-256 Soulmark hash, C2PA Content Credentials. Strip-proof: metadata recoverable via hash registry even if XMP is removed. Verification - Aegis Provenance Verification — "Shazam for Art." Perceptual hash lookup against 100K+ scale LSH index (16x4 bands). Verify any image's provenance chain in <500ms. Free tier available. Dataset Access - Alexandria Aeternum — 2M+ museum artworks across 7 world-class institutions (Met, Rijksmuseum, Smithsonian, NGA, Chicago, Cleveland, Paris). Search, preview, and purchase enriched training data. Human_Standard and Hybrid_Premium tiers with auto-generated AB 2013 + EU AI Act compliance manifests. Permanent Storage - Arweave Permanent Storage — Store artifacts on Arweave L1 for 200+ year permanence. No AR tokens needed — pay in USDC via x402 and we handle the rest. Native AR SDK, direct L1 posting, transaction ID returned for on-chain verification. Your art outlives every server. NFT Minting - Mintra Blockchain Minting — Mint provenance-tracked NFTs on Polygon. Metadata-rich tokens with full Golden Codex schema on-chain. Archivus (Arweave) + Mintra (Polygon) pipeline: permanent storage → immutable ownership in one call. Pricing — Genesis Epoch: 20% off all services for 90 days. Volume discounts auto-apply per wallet (100+ 25% off, 500+ 37% off, 2000+ 50% off). Enterprise packages from $8,000.

AI training dataset marketplace — 2M+ museum artworks across 7 world-class institutions with on-demand 111-field Golden Codex AI enrichment. x402 USDC micropayments on Base L2. First monetized art/provenance MCP server. Research-backed: dense metadata improves VLM capability by +25.5% (DOI: 10.5281/zenodo.18667735). The complete creative AI pipeline exposed as MCP tools. From generation to permanent storage — every stage available via x402 USDC micropayments on Base L2. Generation - SD 3.5 Large + T5-XXL — Stable Diffusion 3.5 Large with T5-XXL text encoder on NVIDIA L4 GPU. High-fidelity image generation with superior prompt adherence. LoRA support (Artiswa v2 style transfer). Upscaling - ESRGAN x4 Upscaler — Real-ESRGAN x4plus on NVIDIA L4 GPU (24GB VRAM). Takes 1024px to 4096px in ~1.15s. Production-grade super-resolution for print and archival quality. AI Enrichment - Golden Codex Metadata Creation (Nova) — 111-field deep visual analysis powered by Gemini VLM. Color harmony, composition, symbolism, emotional journey, provenance chain, archetypal resonance. 2,000-6,000 tokens per artwork. Research-backed: +25.5% VLM improvement (DOI: 10.5281/zenodo.18667735). Metadata Infusion - Atlas XMP/IPTC/C2PA Infusion — Embed Golden Codex metadata directly into image files via ExifTool. XMP-gc namespace, gzip+base64 compressed payload, SHA-256 Soulmark hash, C2PA Content Credentials. Strip-proof: metadata recoverable via hash registry even if XMP is removed. Verification - Aegis Provenance Verification — "Shazam for Art." Perceptual hash lookup against 100K+ scale LSH index (16x4 bands). Verify any image's provenance chain in <500ms. Free tier available. Dataset Access - Alexandria Aeternum — 2M+ museum artworks across 7 world-class institutions (Met, Rijksmuseum, Smithsonian, NGA, Chicago, Cleveland, Paris). Search, preview, and purchase enriched training data. Human_Standard and Hybrid_Premium tiers with auto-generated AB 2013 + EU AI Act compliance manifests. Permanent Storage - Arweave Permanent Storage — Store artifacts on Arweave L1 for 200+ year permanence. No AR tokens needed — pay in USDC via x402 and we handle the rest. Native AR SDK, direct L1 posting, transaction ID returned for on-chain verification. Your art outlives every server. NFT Minting - Mintra Blockchain Minting — Mint provenance-tracked NFTs on Polygon. Metadata-rich tokens with full Golden Codex schema on-chain. Archivus (Arweave) + Mintra (Polygon) pipeline: permanent storage → immutable ownership in one call. Pricing — Genesis Epoch: 20% off all services for 90 days. Volume discounts auto-apply per wallet (100+ 25% off, 500+ 37% off, 2000+ 50% off). Enterprise packages from $8,000.

AI training dataset marketplace — 2M+ museum artworks across 7 world-class institutions with on-demand 111-field Golden Codex AI enrichment. x402 USDC micropayments on Base L2. First monetized art/provenance MCP server. Research-backed: dense metadata improves VLM capability by +25.5% (DOI: 10.5281/zenodo.18667735). The complete creative AI pipeline exposed as MCP tools. From generation to permanent storage — every stage available via x402 USDC micropayments on Base L2. Generation - SD 3.5 Large + T5-XXL — Stable Diffusion 3.5 Large with T5-XXL text encoder on NVIDIA L4 GPU. High-fidelity image generation with superior prompt adherence. LoRA support (Artiswa v2 style transfer). Upscaling - ESRGAN x4 Upscaler — Real-ESRGAN x4plus on NVIDIA L4 GPU (24GB VRAM). Takes 1024px to 4096px in ~1.15s. Production-grade super-resolution for print and archival quality. AI Enrichment - Golden Codex Metadata Creation (Nova) — 111-field deep visual analysis powered by Gemini VLM. Color harmony, composition, symbolism, emotional journey, provenance chain, archetypal resonance. 2,000-6,000 tokens per artwork. Research-backed: +25.5% VLM improvement (DOI: 10.5281/zenodo.18667735). Metadata Infusion - Atlas XMP/IPTC/C2PA Infusion — Embed Golden Codex metadata directly into image files via ExifTool. XMP-gc namespace, gzip+base64 compressed payload, SHA-256 Soulmark hash, C2PA Content Credentials. Strip-proof: metadata recoverable via hash registry even if XMP is removed. Verification - Aegis Provenance Verification — "Shazam for Art." Perceptual hash lookup against 100K+ scale LSH index (16x4 bands). Verify any image's provenance chain in <500ms. Free tier available. Dataset Access - Alexandria Aeternum — 2M+ museum artworks across 7 world-class institutions (Met, Rijksmuseum, Smithsonian, NGA, Chicago, Cleveland, Paris). Search, preview, and purchase enriched training data. Human_Standard and Hybrid_Premium tiers with auto-generated AB 2013 + EU AI Act compliance manifests. Permanent Storage - Arweave Permanent Storage — Store artifacts on Arweave L1 for 200+ year permanence. No AR tokens needed — pay in USDC via x402 and we handle the rest. Native AR SDK, direct L1 posting, transaction ID returned for on-chain verification. Your art outlives every server. NFT Minting - Mintra Blockchain Minting — Mint provenance-tracked NFTs on Polygon. Metadata-rich tokens with full Golden Codex schema on-chain. Archivus (Arweave) + Mintra (Polygon) pipeline: permanent storage → immutable ownership in one call. Pricing — Genesis Epoch: 20% off all services for 90 days. Volume discounts auto-apply per wallet (100+ 25% off, 500+ 37% off, 2000+ 50% off). Enterprise packages from $8,000.

A Model Context Protocol (MCP) server that provides tools for discovering Kubernetes services and running kubectl port-forward sessions (optionally with separate log windows). It is designed for MCP clients/LLMs that translate natural language into structured tool calls.

Build with live API data. Paste this MCP URL into your AI coding assistant and get instant access to SODAX API data plus SDK documentation that auto-updates from GitBook.

MCP server for the Proxenio verified intent network. Enables AI agents to discover platform capabilities, configure API key authentication, retrieve verified professional matches, and accept introductions with principal-inherited trust controls.

Verifiable Memory-as-a-Service for AI agents. Persistent, searchable, graph-connected knowledge with optional Starknet on-chain proofs. Works locally with zero config (SQLite) or in cloud mode.

DNS, IP, AS, domain reputation, and Lightning Network intelligence. 44 tools for DNS lookups, reverse DNS, passive DNS, IP reputation, threat intelligence, AS/BGP routing, domain rankings, MAC address lookups, and Bitcoin Lightning Network data. No authentication required.

Structured failure knowledge for AI agents — 1,000+ errors across 20 domains. Dead ends, workarounds, error chains, and freshness tracking.

Toleno Network MCP Server — Control your Toleno mining account directly from Claude AI using natural language.

Structured failure knowledge for AI agents — 501 errors across 14 domains. Dead ends, workarounds, and error chains.

First Dutch AI-native energy comparison platform with MCP support. Calculate annual energy costs, compare contracts from all Dutch suppliers, get real-time EPEX dynamic prices, calculate solar panel net metering benefits, and get supplier ratings. Built for Claude and other AI assistants.

MCP Server for Visual Studio bridges your IDE with AI coding assistants like Claude Code, Cursor, Windsurf, and Cline. Unlike file-based tools, this extension provides what AI agents CAN'T do alone: • IntelliSense & semantic code understanding (powered by Roslyn) • Symbol search - definitions, usages, inheritance hierarchies • Solution/project navigation and document outlines • Build execution with clean, structured error output • Async test execution with progress tracking • Solution-wide refactoring (rename symbols across all files) 20 tools designed for AI consumption with token-efficient output. Windows only. Supports VS 2022 (17.13+) and VS 2026.

AI/ML-powered diagnostic engine for SRE Observability on Konflux and OpenShift. It uses the Model Context Protocol (MCP) and 40+ tools to analyze logs, metrics, and traces, enabling automated RCA and predictive analysis.

Description: The Neural Router for DepthOS. A polyphonic Model Context Protocol (MCP) server that orchestrates an ensemble of LLM specialists into a unified development hive mind. Implements the .depthos/touchpoint.md protocol for absolute project alignment.

This server contains 5 tools. It could be used to simulate cascading failure scenario for lifeline network recovery (LNR). It has been tested in a case of Shelby County.

This server contains 6 tools. It could be used to process data for lifeline network recovery (LNR). It has been tested in a case of Shelby County.

A Model Context Protocol (MCP) server that creates a bridge between AI language models and the Trakt.tv API, allowing LLMs to access real-time entertainment data and personal Trakt viewing history. Built with a domain-focused architecture using FastMCP, providing clean separation of concerns across authentication, shows, movies, user data, comments, search, and check-in functionality.

sholarPlot MCP - AI-powered scientific figure generator for researchers. Create publication-ready charts, neural network diagrams, flowcharts & mechanism illustrations that meet Nature/Science/IEEE journal standards in seconds

A Model Context Protocol (MCP) server that provides secure SSH capabilities for AI assistants, enabling remote command execution, SFTP file transfers, and port forwarding with comprehensive security controls. Features: - 🔐 Secure SSH Command Execution - Execute commands on remote servers with granular security controls - 🛡️ Host Allowlisting - Only connect to pre-configured, trusted servers - 📁 SFTP File Operations - Upload, download, list, and delete files on remote servers - 🌉 SSH Port Forwarding - Create secure tunnels to access remote services - 🔄 Connection Pooling - Persistent connections with automatic management - 🔑 SSH Key Authentication - Secure authentication using SSH private keys - ⚙️ SSH Config Integration - Import servers from your existing SSJ config file - ✅ Command Allowlisting - Restrict which commands can be executed - 📦 Named Services - Pre-configured port forwarding services for common use cases - 🎯 Command Templates - Reusable parameterized commands with variable substitution

## Features - **Device Control**: GPIO, PWM, sensors, cameras - **Robotic Arms**: Amber B1, Lucid One with gripper support - **Mesh Networking**: Auto-discovery across LAN - **Security**: AES-256 encryption, token auth ## Installation pip install regennexus

We help AI startups offset inference costs by monetizing user intent with context-aware ads via MCP. Getting Started: Sign up at app.earnlayerai.com to receive your API key, then connect to our MCP server and SDK—see docs.earnlayeraiai.com for the 20-minute integration guide.


Map text into knowledge graphs to create a structured representation of conceptual relations and topical clusters in your documents. Detect content gaps between the topical clusters and generate research questions to drive research and content creation using the powerful Graph RAG technology underpinning InfraNodus. Get additional insights about texts: main topics, keywords, and underlying themes. Connect to your existing InfraNodus graphs or create new ones to enrich analysis and outputs.

https://github.com/enuno/unifi-mcp-server

DevExpress documentation at your AI's fingertips.

A modular Python MCP (Model Context Protocol) Server for analyzing PCAP files. mcpcap enables LLMs to read and analyze network packet captures with protocol-specific analysis tools that accept local file paths or remote URLs as parameters (no file uploads - provide the path or URL to your PCAP file).

A Model Context Protocol (MCP) server that provides LLMs with network information lookup tools through WHOIS and RIPE Database queries.

A powerful IPCONFIG MCP (Model Context Protocol) server built on Cloudflare Workers, providing IP address lookup, geolocation, and network connectivity testing tools for AI assistants.

Quake MCP Server

AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance. Features Kubernetes deployment intelligence with semantic capability management, documentation testing & validation, organizational pattern management, and shared prompts library.

🚀 The ONLY browser automation that bypasses Cloudflare, antibots, and social media blocks. Supercharge any MCP-compatible AI agent with undetectable, real-browser automation. No CAPTCHAs. No blocks. Just results.⚡ 30-second setup • 🛡️ Undetectable by design • 🏆 98.7% success rate on protected sites • 🕵️ Full network debugging via AI chat Features: Works on protected sites that block traditional automation- Pixel-accurate element cloning via Chrome DevTools Protocol - Full network debugging through AI chat — see every request, response, header, and payload- Your AI agent becomes a network detective — no more guessing what APIs are being called- 🎛️ Modular architecture — disable unused sections, run minimal installs- ⚡ Lightweight deployments — from 21 core tools to full 88-tool arsenal- Clean MCP integration — no custom brokers or wrappers needed- 88 focused tools organized into 11 logical sections

A comprehensive Model Context Protocol (MCP) server for Nextcloud integration, providing AI agents with secure access to Nextcloud's file management, sharing, user administration, and system monitoring capabilities.

The OPNsense MCP Server provides comprehensive network management capabilities through the Model Context Protocol (MCP), enabling natural language interaction with your OPNsense firewall. Manage devices, monitor traffic, configure firewall rules, and troubleshoot network issues using AI chat interfaces. Example: Find devices: "Show me all devices on the network" Device identification: "What is morpheus doing on the network?" Network topology: "Show me LLDP neighbors" With a good model like Cursor auto-mode the capabilities are awesome and combine with results of other mcp tools.

A Model Context Protocol (MCP) server for managing Rook Ceph storage clusters in Kubernetes environments.

mcp-kubernetes-ro is a Model Context Protocol (MCP) server providing read-only access to Kubernetes clusters for AI assistants. It enables AI models to list resources, get resource details, retrieve pod logs, discover API resources, and perform base64 encoding/decoding operations - all while maintaining security through read-only access. The server leverages your local kubectl configuration (even when kubectl is not required to be installed) and provides a safe, read-only interface to your Kubernetes clusters, preventing any destructive operations while allowing comprehensive cluster inspection and troubleshooting capabilities.

.NET bindings for VMware VIX API with Model Context Protocol server for AI-driven virtual machine automation. Enables natural language control of VMware VMs through AI assistants like Cursor IDE.

Make AI work for teams, communities and collaborative environments everywhere 🤖💝

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Authorize.Net (beta): https://www.cdata.com/download/download.aspx?sku=CWZK-V&type=beta

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for SAP Netweaver Gateway (beta): https://www.cdata.com/download/download.aspx?sku=GCZK-V&type=beta

k8s-mcp-server is a Kubernetes and Helm management tool based on Model Context Protocol (MCP), designed specifically for n8n workflow automation platform. Core Features: Kubernetes Management: Provides 11 kubectl tools supporting 19 resource types for querying, monitoring, and management Helm Integration: Complete set of 5 Helm tools including release management, status queries, and configuration management n8n Compatibility: Supports SSE (Server-Sent Events) connections for direct integration into n8n workflows Project Status: Version: 2.2.0 Completion: 89.5% (34/38 features) Architecture: Node.js + Express + MCP SDK Deployment: Docker containerized, supports Kubernetes cluster deployment Main Tools: Resource Query: kubectl_get (with label selector support) Resource Monitoring: Top series tools (nodes/pods/containers) Deployment Management: Scaling, restart, HPA editing Helm Management: Release status, configuration values, deployment history Security Features: Strict input validation and character filtering Only supports safe read and controlled management operations Runs as non-root user with principle of least privilege

These tools are used to query sample-related information within the foundational network data set. Currently, this includes access to sandbox analysis data.

These tools are used to query IP-related information within the foundational network data set. Currently, this includes IP geolocation lookup.

These tools are used to query domain-related data within the broader scope of foundational network security data. This includes co-occurring domains, domain popularity rankings, webpage content, and domain intelligence from the Libra data platform.

Core network security data includes PassiveDNS resolution records, domain and IP registration details, website certificate information, and IOC (Indicators of Compromise) database queries.

网络基础数据，包括passivedns解析数据、域名和IP的注册信息、网站证书、IOC库的查询。

网络基础数据，包括passivedns解析数据、域名和IP的注册信息、网站证书、IOC库的查询。

The most powerful open-source Cairo code generator.

Peliqan is an all-in-one data platform with ETL and built-in data warehouse. The Peliqan MCP server allows you to connect to all your business applications to query data, ask analytical questions on your data etc. Use Peliqan to expose your SaaS business applications via MCP and to get real-time access to all internal company data. Available connectors include: Adobe Commerce, AFAS, Aircall, Airtable, Akeneo, AllGravy, Amazon QuickSight, Apache Airflow, Apache Superset, Apple App Store, Aproplan Letsbuild, Archisnapper, ArchX, S3, BambooHR, Bank Transactions, Benchmarking Alliance, Bigcommerce, BigQuery, Billit, Billtobox Banqup, Billtrust (iController), Bol, Brevo, CareerPro FLA (RSZ), Chargebee, Cin7 Core, Cin7 Omni, ClickHouse, CreditSafe, d2o PMI, Docebo, Dropbox, Dynamics 365 Finance and Operations (AX), DynamoDB, Elastic Search, Elina PMS, Exact Online, Excel, Facebook, FDT Sellus, FHIR, FileMaker, FortNox, Freshdesk, GeoCode API, GeoDynamics, GeoFleet, Github, Globis, Gong, Google Ads, Google Analytics, Google Calendar, Google Docs, Google Drive, Gmail, Google Play Store, Google Sheets, HelpScout, Heylog, HubSpot, HubSpot Analytics, IFS ERP, Intercom, IonBiz, Jira, Klarna, Klaviyo, Klenty, LightSpeed eCom, LightSpeed Retail (R-Series), Linkedin, Lobster Logistics Cloud, Looker, Magento, Magicline, Mailchimp, Mailerlite, Metabase, Mews, Microsoft Business Central Custom API, Microsoft Dynamics 365 Business Central, Microsoft Fabric DWH, Microsoft Outlook, Microsoft Outlook Calendar, Microsoft Teams, Mixpanel, Monday, MongoDB, MQTT, SQL Server, mWorker, MySQL, N11, NetSuite, NMBRS, Norges Bank Currencies, Notion, Odoo, OneDrive, OpenAI, Optioryx, Parseur, PayPal, Pimcore, Pipedrive, Planday, Ponto, Postgres, PostHog, Postmark, Power BI, Power Office, Qdrant, Qlik, Quickbooks, Redshift, Salesforce, SAP SQL Anywhere (Sybase), SaySimple, SD Worx, SendCloud, SFTP, Sharepoint, Shiji ReviewPro, Shopify, Simplicate, Slack, Snowflake, Solvice, Starshipit, Stripe, sugar CRM, Supabase, Superagent, Tableau, Teamleader Focus, Teamleader Orbit, Test connector, TraxGo, Trimble Connect, Trino, TripleTex, Typeform, Unleashed ERP, Veroo, VIES EU VAT validation, Visma Bouwsoft, Visma E-conomic, Visma Net (Visma.net), Vitally.io, Weather API, Weclapp, Whatsapp, Workday, Xero, Yuki, Zendesk, Zenvoices, Ziggu, Zoho Creator, Zoho CRM, Zoho Invoice, REST, CSV, API, XML, JSON, API driver, OData, FTP, SFTP, Parquet and many more...

Demo eks mcp server

convert any remote MCP Server as blueprint in seconds

An MCP (Model Context Protocol) server application for Kubernetes operations, providing a standardized API to interact with multiple Kubernetes clusters simultaneously using multiple kubeconfig files.

A Model Context Protocol (MCP) server that enables AI assistants to interact with Kubernetes clusters. It serves as a bridge between AI tools (like Claude, Cursor, and GitHub Copilot) and Kubernetes