#learning

AI-integrated tools for learning, writing, and publishing. ProvenanceAI builds free MCP tools that help authors develop and protect their voice, editors assess manuscript quality, instructors design humanities courses, and researchers produce defensible, well-sourced work. Current tools cover editorial analysis: voice profiling, authenticity scoring, structural review, style consistency, research grading, and manuscript readiness. Expanding into curriculum design, academic writing, and book production workflows. No email gate. Every tool returns a full structured result on the first call. Powered by ProvenanceAI × Exact Rush.

Multilingual AI study tool. Paste any public video URL to get a structured Knowledge Pack — summary, key ideas, glossary, quiz, transcript with timestamps — in Spanish, Portuguese, German, or English. Ships as an MCP server with one anonymous tool (vozclara_generate_pack) plus three OAuth-protected tools (search_my_library, ask_video, export_anki). Cloudflare Workers + Llama 3.3 70B (free/Pro) or Claude Sonnet 4.5 (Pro Plus). Free tier requires no signup. A LEON MARÉ product.

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.*

Quizlar is the learning MCP server. It turns whatever source the user brings — a YouTube lecture, a PDF, a URL, a textbook passage, or a pasted block of notes — into flashcards, then runs interactive quizzes with FSRS spaced-repetition scheduling so the material actually sticks. Every tool maps one-to-one to something a real learner does: ingest, quiz, track progress, review what's due. Built as a voice-first tutor (LiveKit + Deepgram + ElevenLabs); the MCP surface exposes the same primitives the voice agent uses internally, so your agent gets production-grade grading, STT-aware answer parsing, and the same FSRS scheduler that powers the consumer app. Three use cases: 1. "Quiz me on X." Call quiz_me(topic) — a composite tool that builds the deck and starts the quiz in one step. Then loop submit_answer → end_quiz. Grading is tier-1 exact match → phonetic fuzz → short LLM fallback (the same pipeline that ships in the voice product). 2. Study from a YouTube lecture. create_deck_from_youtube pulls the transcript, clusters it into concepts, and generates cards proportional to the video length. Poll get_job_status, then run the quiz loop. 3. Daily spaced-repetition review. get_study_recommendations returns exactly the cards due under the user's FSRS schedule, prioritised across all decks. Quizlar is the scheduler of record — your agent executes the plan instead of reinventing one each session. Auth: Bearer token (sk-qz-<32 chars>) for headless installs, or full OAuth 2.1 / DCR / PKCE for one-click clients (Smithery, Claude Connector). Mint keys at https://quizlar.app/settings/api-keys. 22 tools total. Voice and text equal-status. Education-first.

Strata is a self hosted AI memory server. Your AI remembers everything across every session, on your own hardware. Key features: . Semantic search (find memories by meaning, not keywords) . Per-agent API keys with granular permissions . 3D constellation viewer with live agent activity . File vault (attach real documents to memories) . CSV audit log (full transparency on every agent action) . Pre-Strata history import (your memory doesn't start at install day) . Global MCP kill switch (emergency brake, only a human can undo) . Automatic deduplication . 10 structured thought types . Backend using PostgreSQL . Runs on a Raspberry Pi Always on, always local, always yours.

Agent learning infrastructure that captures experience, surfaces what works, and builds reusable capabilities. MCP-native with 94.4% LongMemEval accuracy. Supports Claude Code, Gemini CLI, Codex CLI, and more.

MCP server for data analytics — upload CSV files or connect Shopify, Stripe, GA4, and Search Console. 50+ statistical and ML tools including regression, clustering, time series, hypothesis testing, and customer analytics. Semantic tool discovery matches your question to the right analysis automatically.

Persistent memory MCP for AI agents — Knowledge graph + Hebbian learning + Anti-hallucination. 12 tools, 1 dependency, zero manual setup.

Career and workforce intelligence built on a deep HR ontology — skill taxonomies, role definitions and responsibilities, compensation and incentive structures, learning and development pathways, sourcing strategies, and role/skill evolution mapping. This structured foundation, combined with a RAG knowledge base curated from 50+ premium sources (HBR, McKinsey, BCG, Gartner, Forrester) and updated 3x daily with live web research, powers 6 guided skills and 42 MCP tools for two audiences: working professionals getting personalized career intelligence (CV optimization, salary benchmarking, career strategy), and HR/TA teams running structured talent evaluation, candidate shortlisting, compensation analysis, and consulting-grade workforce research reports. Example Use Cases (for HR/TA teams): 1. Custom Evaluation Models — Train CareerProof on your organization's existing assessment rubrics, scorecards, and evaluation criteria to build custom eval models that evaluate candidates through your specific lens. Upload your competency frameworks and historical assessments, then run inference on new candidates — scored and ranked exactly how your team would, at scale. 2. Candidate Evaluation & Shortlisting — Set up a hiring context with company profile and job description, upload candidate CVs, then batch-rank them with GEM competency scoring and JD-FIT matching. Apply your custom eval models for organization-specific scoring, or deep-dive any candidate with a 360-degree evaluation including tailored interview questions derived from skill taxonomy analysis. 3. Workforce Research Reports — Generate consulting-grade PDF reports across 16 types (salary benchmarking, skills gap analysis, org design, DEI assessment, succession planning, sourcing strategy, and more). Each report is grounded in real-time market data from premium sources and structured around HR ontology — role definitions, compensation structures, L&D pathways, and skill evolution mapping. 4. Compensation & Incentive Benchmarking — Get market-calibrated salary and total compensation intelligence for any role, location, and industry. Analysis is structured around compensation and incentive frameworks from the HR ontology, enriched with live web research and curated knowledge base data covering base salary, equity, bonuses, and benefits. Example Use Cases (for the working professional or career coach): 1. Career Intelligence Chat (Hyper-Personalized) — Ask career strategy questions and get hyper-personalized responses that fuse your CV context with deep insights from the career and workforce RAG knowledge base. Salary benchmarks calibrated to your function and location, industry disruption analysis mapped to your skill profile, and career pivot recommendations grounded in role evolution data — not surface-level answers, but intelligence drawn from the same sources that inform executive strategy. 2. CV Optimization (Hyper-Personalized) — Upload your CV and receive a hyper-personalized positioning pipeline that combines your actual experience with deep insights from our career and workforce RAG knowledge base. Market analysis calibrated to your industry and seniority, career opportunity identification grounded in role/skill evolution data, and targeted edits with trade-off analysis — not generic advice, but intelligence shaped by 50+ premium research sources and your unique career trajectory.

Convert topics or existing files into professional presentation videos with automated slides and narration. Streamline content creation by generating outlines, scripts, and high-quality text-to-speech audio in a single workflow. Manage the entire production pipeline from initial rendering to final video export for polished results.

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.

Production speech AI server with pronunciation scoring, speech-to-text, and text-to-speech. 10 tools, 7 resources, 3 prompts for language learning and speech assessment workflows. Powered by a 17MB model that achieves sub-300ms latency with phoneme-level accuracy.

Production speech AI server with pronunciation assessment, speech-to-text, and text-to-speech. 10 tools, 7 resources, 3 prompts for language learning, speech assessment, and audio processing workflows. Powered by a 17MB model that achieves sub-300ms latency.

Turn slow PyTorch into fast CUDA/Triton kernels. 32 parallel swarm agents optimize your code on real datacenter GPUs (B200, H200, H100, A100) with up to 14x speedup over torch.compile.

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.

用于图片搜索,来搜寻你想要的图片吧

KinielaGPT es un servidor MCP (Model Context Protocol) diseñado para potenciar tus predicciones de la Quiniela mediante un análisis avanzado de datos. Combina las probabilidades oficiales de LAE con un análisis contextual profundo: histórico de enfrentamientos, rachas recientes, clasificación y rendimiento como local o visitante. Ofrece tres estrategias de predicción, detección de sorpresas y un análisis pormenorizado partido a partido.

Persistent codebase intelligence that gives agents memory across sessions.

Transform your AI agents into Apple development experts! Apple RAG MCP gives you instant access to official Swift docs, design guidelines, and comprehensive Apple platform knowledge through cutting-edge RAG technology. With professional AI reranking and hybrid search across iOS, macOS, watchOS, tvOS, and visionOS documentation plus Apple Developer YouTube content, you'll get precise, contextual answers every time. Compatible with Cursor, Claude Desktop, and all MCP tools - start building smarter Apple apps today!

Konnektoren MCP Server helps you learn German faster and smarter. Instantly find answers to grammar questions, discover the best exercises for your level, and create your own interactive challenges—all in one place. Whether you’re a student, teacher, or self-learner, this server gives you easy access to high-quality German learning resources and tools, right inside your favorite AI assistant. No technical setup required—just connect and start improving your German today!

A comprehensive MCP server providing financial data through unofficial Yahoo Finance APIs for educational purposes. Features 20+ tools including real-time stock prices, financial statements, analyst recommendations, ESG scores, company profiles, and historical data. Built with Python and yahooquery library, offering production-ready error handling and cross-platform compatibility. Perfect for learning financial analysis, educational research, and market data exploration. Note: Uses unofficial APIs - not for commercial trading decisions.

A learning project for MCP server integration, between eventcatalog.io and cursor.

A powerful Model Context Protocol server for LinkedIn interactions that enables AI assistants to search for jobs, generate resumes and cover letters, and manage job applications programmatically.

A Model Context Protocol (MCP) server for agentic retrieval of financial data. This server leverages YFinance to provide a simple and efficient way to access historical stock prices, dividends, stock splits, company information, and other financial metrics. This MCP server is designed to be used with various LLM applications that support the Model Context Protocol, such as Claude Desktop and Cursor. It allows users to retrieve financial data in a structured way, making it easy to integrate into AI applications.

A Model Context Protocol (MCP) server for agentic retrieval of financial data from Yahoo Finance. This server leverages YFinance to provide a simple and efficient way to access historical stock prices, dividends, stock splits, company information, and other financial metrics. This MCP server is designed to be used with various LLM applications that support the Model Context Protocol, such as Claude Desktop and Cursor. It allows users to retrieve financial data in a structured way, making it easy to integrate into AI applications.

A Model Context Protocol (MCP) server for agentic retrieval and semantic search over unstructured and structured data using Milvus, a high-performance vector database. This server enables large language model (LLM) applications to efficiently index, store, and retrieve vector embeddings derived from diverse data sources—such as documents, images, metadata, or logs. By leveraging Milvus, the MCP server supports similarity search and contextual retrieval, enabling intelligent access to relevant information based on natural language queries. Designed for integration with MCP-compatible clients, this solution provides a scalable, low-latency foundation for building AI-powered applications with contextual awareness and retrieval-augmented generation (RAG) capabilities.

A Model Context Protocol (MCP) server for agentic retrieval of financial data from Yahoo Finance. This server leverages YFinance to provide a simple and efficient way to access historical stock prices, dividends, stock splits, company information, and other financial metrics. This MCP server is designed to be used with various LLM applications that support the Model Context Protocol, such as Claude Desktop and Cursor. It allows users to retrieve financial data in a structured way, making it easy to integrate into AI applications.

This MCP server provides documentation about Strands Agents to your GenAI tools, so you can use your favorite AI coding assistant to vibe-code Strands Agents.

Anki MCP gives you conversational access to your Anki flashcards—quiz yourself, create cards, analyze progress, and manage your collection with natural language.

Deep Learning capstone project about MCP servers

An open-source MCP (Model Context Protocol) server that enables AI agents to record and retrieve learning activities through xAPI-compliant Learning Record Stores

学习模型上下文协议(MCP)服务器 - 翻译和学习资源

MCP Server Repository

A repository to learn MCP Server with implementing git features.

Let AI agents like ChatGPT & Claude use real-world local/remote tools you approve via browser extension + optional MCP server

Learning mcp server and clients through Documentations

This repo is dedicated to learning and working with large language models (LLMs), prompt engineering, and modern GenAI tools such as LangChain, RAG, and vector databases.

A collection of articles and guides on AI, Generative AI, and Machine Learning, featuring practical examples in Python, TypeScript, and MCP server development.

Final unified interface for global users. Just describe your server, paste your API key (Claude/OpenAI/Grok), and this library will build, test, and deploy the full MCP server locally or remotely.

Uses Claude or OpenAI API to convert prompt-mapped input into concrete MCP server components such as tools, resource templates, and prompt handlers.

Automatically generates a full MCP server codebase (Node/Python/Java) using the validated schema, outputting modular files for CLI-based execution or Claude Desktop connection.

CLI tool to scaffold, run, and test MCP servers locally with Node.js or Python, integrated with Claude and OpenAI key injection and auto-link to Claude Desktop.

Enables any MCP-compliant agentic platform (Claude, Grok, TypingMind, Cursor, etc.) to auto-discover generated MCP servers and sync capabilities from build metadata.

Analyzes user-described build features (e.g. database, API integration, tools) and extracts core server requirements like resources, tools, prompts, external systems, and transports needed for MCP.

Generates optimal Claude/OpenAI-ready prompts to build each part of the MCP server (resources, tools, prompts) from the input generated by `mcp_input_analyzer`.

Learning about MCP server

This MCP server implemented with spring AI and Oracle DB is mainly focused in learning and testing purpose

Interact with cloudera AI api to manage job, apps, models

Digimon Engine — Multi-Agent, Multi-Player Framework for AI-Native Games and Agentic Metaverse

My first MCP (Model Context Protocol) server

The repo is based on Model Context procotol of Python SDK, including DL models in CV, and provide the abilities to the LLM or vLLM model

A minimal agentic app to interact with OLLAMA models leveraging multiple MCP server tools using BeeAI framework.

My first MCP Server for learning

Mirror of

Model Context Protocol (MCP) with Gemini 2.5 Pro. Convert conversational queries into flight searches using Gemini's function calling capabilities and MCP's flight search tools

An attempt to create an MCP server so I can learn more about it

Learn TypeScript chatting effortlessly with AI

Personal Context Technology for AI Personalization MCP server

Model Context Protocol (MCP) with Gemini 2.5 Pro. Convert conversational queries into flight searches using Gemini's function calling capabilities and MCP's flight search tools

MCP server for training Linear Regression Model.

YouTube MCP Server is an AI-powered solution designed to revolutionize your YouTube experience. It empowers users to search for YouTube videos, retrieve detailed transcripts, and perform semantic searches over video content—all without relying on the official API. By integrating with a vector database, this server streamlines content discovery.

Mirror of

Learning how to build mcp-servers to connect in llms via langchain

Learn MCP by building from Scarch

A server for managing contextual data in DICOM tools, supporting medical imaging and machine learning workflows.

the terminal client for Ollama

Learning repository: conversations and notes from my learning sessions with Claude. And all files are upload by Claude MCP server