Ai Ml

Cohere API

Enterprise-focused LLM platform specializing in retrieval-augmented generation (RAG), embeddings, and text generation. Known for Command models (generation) and Embed models (semantic search), plus Rerank for search quality.

Mistral AI API

French AI company offering efficient, open-weight LLM models with strong performance-to-cost ratio. Mistral Large (flagship), Mistral Small, and specialized models for code, math, and embeddings via API and self-hosting.

Modal

Serverless cloud compute platform for running Python functions on demand with GPU acceleration, enabling ML inference, training, and data processing without infrastructure management.

DeepL API

Neural machine translation API that delivers human-quality translations across 30+ languages, with an official MCP server for agent integration.

AssemblyAI API

Speech-to-text API with built-in LLM-powered features including transcription, speaker diarization, sentiment analysis, summarization, and PII detection from audio.

Deepgram API

Deepgram's speech-to-text API offering fast, accurate audio transcription with real-time streaming, speaker diarization, sentiment analysis, and language detection.

Azure OpenAI Service API

Microsoft's enterprise deployment of OpenAI models (GPT-4, GPT-3.5, DALL-E, Whisper, Embeddings) on Azure infrastructure. Same models as OpenAI but with Azure's compliance, data residency, SLAs, and enterprise security.

Lambda Labs Cloud API

GPU cloud computing API providing on-demand and reserved access to NVIDIA H100, A100, and V100 GPU clusters for ML training, fine-tuning, and inference workloads.

AI21 Labs API

Enterprise LLM platform from Israeli AI company AI21 Labs. Features Jamba models (hybrid SSM-Transformer architecture) and specialized document summarization and question-answering capabilities.

Groq API

Groq's ultra-fast LLM inference API using custom Language Processing Units (LPUs) to serve open-source models (Llama, Mixtral, Gemma) at industry-leading speeds.

Together AI API

Together AI's inference API for running open-source LLMs (Llama, Mistral, Mixtral, etc.) with OpenAI-compatible endpoints for chat, completion, and embedding tasks.

fathom-mcp

An MCP (Model Context Protocol) server (built with FastMCP) that wraps the Fathom AI API to provide MCP tools for listing meetings, fetching summaries and transcripts, listing teams and team members, and managing meeting webhooks.

Weights & Biases

ML experiment tracking and model management platform that logs training metrics, visualizes model performance, manages model artifacts, and monitors LLM applications in production via a REST API and Python SDK.

turn-mcp

turn-mcp-web provides a self-hosted MCP server exposing a human-in-the-loop tool (turn.wait/turn_wait) that pauses an agent and forwards control to an operator via a browser console. It also exposes related REST endpoints for pending waits, responding/canceling/extending waits, and real-time updates via SSE.

pinboard-mcp-server

Provides a FastMCP-based Model Context Protocol (MCP) server exposing read-only tools to search and list Pinboard.in bookmarks (including tag listing) for use by LLM clients at inference time. It uses a Pinboard API token from an environment variable and includes caching and rate-limit handling as described in the README.

Replicate API

Replicate's API for running open-source machine learning models in the cloud, including image generation, LLMs, audio processing, and computer vision models via simple API calls.

ElevenLabs API

ElevenLabs' API for generating ultra-realistic text-to-speech audio, voice cloning, and real-time audio streaming using AI-powered voice synthesis.

Google Cloud Translation API

Google Cloud's machine translation API supporting 130+ languages, available as both a basic REST API and an advanced neural model with glossary and batch support.

LangSmith

LLM observability and evaluation platform from LangChain that traces, monitors, and evaluates LLM application runs including agent chains, with a REST API for programmatic access to traces and evaluation datasets.

Comet ML

ML experiment tracking and LLM observability platform that logs training metrics, compares experiments, manages model versions, and monitors production LLM applications via a REST API and Python SDK.

agent-trade-kit

Provides a local Model Context Protocol (MCP) server and a CLI to connect AI agents/assistants to an OKX account for trading and trading-related operations (market data queries, order management, account/positions, earn, and bots). Keys are configured locally and the MCP server runs as a local stdio process.

Perplexity API

Search-augmented LLM API that grounds responses in real-time web search. Provides up-to-date information with citations, combining LLM reasoning with live web search for factual, current answers.

Hugging Face Inference API

The world's largest open-source model hub with a serverless Inference API for running 250k+ models including LLMs, embeddings, image generation, and specialized NLP tasks via a unified REST interface.

oracle.oci-vision-mcp-server

Provides MCP server integration for Oracle Cloud Infrastructure services, enabling diverse AI model context management.

oracle.oci-speech-mcp-server

Provides MCP server integration for Oracle Cloud Infrastructure's speech services.

openalex-research-mcp

Provides an MCP (Model Context Protocol) server that exposes OpenAlex scholarly data to AI assistants via ~31 specialized tools for literature search, entity lookup, citation/reference analysis, trend analysis, and preset-based (journal/institution) constrained discovery. Includes CLI-based setup for MCP client integration (e.g., Claude Desktop) and supports options like caching, validation, and retry behavior.

Exa MCP Server

Official MCP server from Exa that provides AI assistants with web search, code context retrieval, company research, people search, URL crawling, and an autonomous deep research agent. Available as both a hosted MCP endpoint and a local npm package.

Gemini CLI

Google's open-source AI agent for the terminal that integrates Gemini models for code analysis, generation, automation, and general tasks. Supports MCP server integration, multimodal input, Google Search grounding, and deep GitHub workflow automation.

pdf-reader-mcp

Provides an MCP (Model Context Protocol) server with a single tool, `read_pdf`, to extract PDF text, metadata, page counts, and optionally images (base64 + metadata). Supports local file paths (absolute/relative) and HTTP/HTTPS URLs, including page-range selection and Y-coordinate based ordering to preserve reading/layout flow.

MCP

Provides an MCP (Model Context Protocol) remote server exposing Jina AI tools for URL-to-markdown reading, web/arXiv/SSRN/image search, query expansion, PDF extraction, and embeddings/reranking utilities. Uses Streamable HTTP transport with an endpoint at https://mcp.jina.ai/v1, and supports optional or API-key-gated tools.

openscad-mcp

Provides a Model Context Protocol (MCP) server (built with FastMCP) that lets an AI assistant render, export, validate, and analyze OpenSCAD (.scad) models by running an OpenSCAD subprocess. Supports stdio transport for MCP with optional HTTP/SSE via environment configuration, and includes workspace file management and render caching options.

mcp-stata

mcp-stata is a Model Context Protocol (MCP) server that connects AI agents to a locally installed Stata (17+) installation. It runs Stata commands, can load/inspect datasets and variables, executes .do files, exports graphs, and retrieves stored r()/e() results. It also exposes an additional localhost-only HTTP API for a data-browser UI with bearer-token access.

openrouter-mcp-multimodal

A Model Context Protocol (MCP) server that routes requests to OpenRouter models and exposes tools for text chat (including multimodal message content), image analysis (with server-side image fetching and Sharp-based optimization), image generation, and model search/validation.

polymarket-mcp

An MCP (Model Context Protocol) server that exposes PolyMarket prediction-market data via four MCP tools: market details, market listing with pagination, current prices, and historical price/volume data over selectable timeframes. It connects to the PolyMarket API using an API key and provides human-readable responses with stated handling for common API error conditions (rate limiting, invalid keys/markets, timeouts, malformed responses).

alpha-vantage-mcp

Provides an MCP server that exposes Alpha Vantage market-data functionality (stocks, companies, crypto, options, ETFs, and earnings) via a set of MCP tools.

houtini-lm

Provides an MCP server that connects Claude Code to a local (LM Studio/Ollama/vLLM/llama.cpp) or OpenAI-compatible LLM endpoint. It routes bounded “grunt work” tasks to the cheaper model (e.g., code review drafts, tests, commit messages, format conversion, mock data, embeddings), while leaving complex reasoning and orchestration to Claude. Includes model discovery/caching, per-model routing hints, performance stats, and tool functions such as chat/custom_prompt/code_task/embed/discover/list_models.

Anthropic API

Anthropic's API providing access to Claude models for language understanding, reasoning, coding, and agentic tasks including computer use, tool use, and extended thinking.

youtube-connector-mcp

Provides a local Model Context Protocol (MCP) server that connects an MCP client (e.g., Claude/Cursor/etc.) to the YouTube Data API v3 to search and fetch YouTube data such as videos, channels, playlists, transcripts, and comments.

erickwendel-contributions-mcp

Provides a Model Context Protocol (MCP) server exposing tools, prompts, and resources to query Erick Wendel’s public contributions (talks, posts, videos) with filtering and pagination.

memory-lancedb-pro

memory-lancedb-pro is an OpenClaw plugin that provides long-term “memory” storage and hybrid retrieval on top of LanceDB. It combines vector (ANN) search with BM25 full-text search, fuses results, applies cross-encoder reranking, and runs a multi-stage scoring pipeline including recency/importance/length normalization/time decay plus diversity (MMR). It also supports multi-scope isolation, auto-capture/auto-recall hooks in the OpenClaw lifecycle, optional Markdown mirroring, long-context embedding chunking, and a management CLI for memory CRUD/migration/reindexing.

OpenAI API

OpenAI's API providing access to GPT-4, GPT-4o, DALL-E, Whisper, TTS, and embedding models for language, vision, image, audio, and multimodal AI capabilities.

facebook-ads-library-mcp

Provides a Model Context Protocol (MCP) server that lets an AI agent search and retrieve information from Facebook’s public Ads Library by brand/page (via ScrapeCreators), and optionally analyze ad images/videos (video analysis via Google Gemini). Includes caching, request deduplication, and batch-oriented tools for platform IDs, ad retrieval, and (for videos) batched analysis.

muapi-cli

Command-line interface for muapi.ai to generate and process generative media (images, videos, audio), manage account/credits and API keys, upload files, and optionally run an MCP (Model Context Protocol) server for agent integration.

omdb-mcp-server

Provides a Model Context Protocol (MCP) server exposing OMDB (Open Movie Database) search and movie-details retrieval. Implements MCP tools (search_movies, get_movie_details, get_movie_by_imdb_id) over HTTP JSON-RPC and/or SSE transport, with automatic caching and Swagger/OpenAPI documentation for REST-style endpoints (including cache management).

dassian-adt

MCP server that connects AI assistants to an SAP system via the ADT API for ABAP development tasks (read/write/activate objects, manage transports, run syntax/ATC checks, query tables, execute ABAP “run”, and handle sessions/health). Provides both stdio (local) and HTTP (team) MCP transports.

rust-mcp-server

An MCP (Model Context Protocol) server for Rust codebases that exposes tools to parse/check Rust files, index workspaces into analysis graphs, navigate to definitions/references, detect code smells, and provide refactoring suggestions. It communicates via JSON-RPC 2.0 over stdio (e.g., run as a subprocess in MCP clients), with Docker-based deployment described in the README.

google-ai-mode-mcp

Provides an MCP server tool (search_ai) that automates using Google AI Mode in a local browser session, extracts the synthesized answer and citations, and returns them as Markdown plus source links. Includes CAPTCHA handling, language handling, and persistence of a browser profile.

perplexity-mcp-server

Provides a Model Context Protocol (MCP) server (and CLI mode for testing) that lets LLM agents query Perplexity AI’s search capabilities (general web, academic, financial, and filtered search) and optionally cache results locally for later retrieval by ID.

inkos

InkOS is a Node.js/TypeScript CLI/agent tool that autonomously generates, audits, and revises novels chapter-by-chapter using a multi-agent pipeline (plan/compose/draft/audit/revise), with continuity tracking via “truth” files, schema-validated JSON state deltas, and rollback/versioning. It also includes an optional local web studio and an OpenClaw-compatible skill interface with structured (e.g., --json) command outputs.

owui-mcp-server

Provides an MCP server that exposes Open WebUI Knowledge Bases as MCP tools/resources, enabling clients to list knowledge bases, fetch knowledge base info, and run semantic search against a specific knowledge base. Supports stdio (local) and HTTP (remote) transports and proxies requests to the Open WebUI API using an API token.

sora-mcp

Provides an MCP server (stdio for local clients and HTTP for remote clients) that wraps OpenAI Sora 2 video generation APIs. Exposes tools to create videos, check job status, list jobs with pagination, download/save completed videos, remix existing videos, and delete jobs/assets.

cognition-wheel

Provides an MCP (Model Context Protocol) server that answers questions by consulting multiple LLM providers (Anthropic, Google, OpenAI) in parallel and synthesizing the results into a final response via a single tool (`cognition_wheel`).

mcp_on_ruby

Provides a Ruby/Rails integration that exposes a Rails app as a Model Context Protocol (MCP) server, letting you publish application tools (callable functions with JSON Schema input validation) and resources (URI-templated data exposure) over an HTTP/JSON-RPC style transport, with configurable authentication, rate limiting, and security protections.

rmcp

rmcp is a Python-based Model Context Protocol (MCP) server that exposes 52 statistical analysis tools (organized into categories) backed by a curated whitelist of CRAN R packages. It can be run locally (stdio for MCP clients such as Claude Desktop; optional HTTP transport for web apps) or used via a live HTTPS endpoint with interactive docs and health checks.

excel-mcp-server

Provides an MCP server (stdio by default; optional SSE HTTP transport) for reading and writing Microsoft Excel spreadsheets (xlsx/xlsm/xltx/xltm), including reading/writing cell text and formulas, and (on Windows) capturing sheet ranges as images.

modelcontextprotocol

Provides an MCP server that exposes Perplexity API capabilities as MCP tools for AI assistants, enabling real-time web search and model-based Q&A/research (search, ask, research, reasoning). Supports both stdio (typical MCP clients) and an optional HTTP deployment mode.

context-harness

Context Harness ingests external knowledge from connectors into a local-first SQLite store (with FTS5 keyword search and optional embeddings), then exposes retrieval via a CLI (`ctx`) and an MCP-compatible HTTP server (plus REST endpoints) for AI tools like Cursor and Claude.

mcp-server-signoz

Provides a Go-based Model Context Protocol (MCP) server (STDIO transport) that exposes SigNoz observability data access as MCP tools. It connects to a user’s SigNoz instance (URL plus optional API key), supporting queries for dashboards, services, APM metrics, and trace/log retrieval via ClickHouse SQL, as well as executing custom ClickHouse or SigNoz builder queries within time ranges.

mcp-server-siri-shortcuts

MCP server that provides access to Siri shortcuts

mission-control

Mission Control is an open-source, self-hosted AI agent orchestration dashboard that provides task dispatch and multi-agent workflow management, real-time monitoring (WebSocket/SSE), cost/token tracking, and security governance (RBAC, trust scoring, secret detection, and MCP/tool call auditing). It uses a SQLite-backed local-first setup (Next.js/TypeScript).

paperqa-mcp-server

Provides an MCP server that wraps PaperQA2 to index a local PDF library and answer questions by reading/searching/synthesizing across those papers. Indexing uses OpenAI embeddings and (optionally) other LLMs configured via environment variables; the tool is intended for use inside Claude Desktop via MCP.

unity-mcp

unity-mcp (MCP for Unity) is a Unity Editor extension that runs a local MCP/HTTP server on the user machine and exposes a rich set of “tools” and “resources” so AI assistants can inspect and modify Unity projects (assets, scenes, scripts, editor actions) and automate workflows.

world-intel-mcp

world-intel-mcp is an MCP (Model Context Protocol) server and companion CLI/dashboard/collector for pulling and analyzing publicly available global intelligence across 30+ domains (markets, FX, bonds, SEC filings, conflict/security, military/aviation, geospatial datasets, news, cyber threats, etc.). It exposes many MCP tools (100+ per README) and supports semantic retrieval using a Qdrant vector store.

mcp-ppt

mcp-ppt is an MCP server that lets an agent create and modify PowerPoint (.pptx) presentations through natural-language-driven tool calls. It supports creating presentations, adding slide types (title, content, section divider, image, table), exporting/saving outputs, and generating SVG-to-image slides.

claude-agent-sdk-python

A Python SDK that enables applications to interact with Claude Code via an async query API and an interactive ClaudeSDKClient. It supports tool use, including in-process custom tools exposed through MCP servers, and hook-based control of the agent loop.

ihale-mcp

Provides a Model Context Protocol (MCP) server (FastMCP-based) for accessing Turkish public procurement information, including EKAP v2 tenders, tender details and announcements (HTML-to-Markdown conversion), OKAS code search, authority (public institution) search, and integrations for ilan.gov.tr-style official ads such as UYAP e-sales.

mcp-ocr-server

Provides an MCP (Model Context Protocol) server for OCR on images using Tesseract OCR and GoCV/OpenCV, including configurable and auto image preprocessing (quality analysis, denoising, thresholding, deskew, contrast/brightness adjustments), worker pooling, and result caching keyed by SHA256.

mcp-server

A Rust implementation of the Model Context Protocol (MCP) that can run over HTTP (including SSE streaming) and over STDIO, exposing MCP JSON-RPC methods for resources, tools, prompts, completion, and protocol/session management. Includes configurable authentication/authorization options and TOML-based configuration/validation.

ta-lib-mcp-server

A read-only Python MCP server that exposes TA-Lib functionality via MCP tools for listing available indicators/categories, fetching indicator metadata, computing indicator values from numeric OHLCV-like inputs, and reporting version information. If TA-Lib is not installed, it still starts and returns actionable errors for TA-Lib-related tools.

yt-mcp-server

yt-mcp-server is a Python MCP server that exposes YouTube-related tools: searching for videos, fetching video and channel metadata, retrieving transcripts (with timestamps), searching within a single transcript, and searching across all videos of a channel for passages matching a query. It can run as a zero-config MCP server (e.g., via uvx) and also supports running a standalone HTTP server using a specified transport.

paperbanana-skill

Provides Claude Code skill definitions (and an underlying Python package) to generate publication-quality academic diagrams, statistical plots, and slide decks from text or structured data, using a multi-agent pipeline with evaluation/self-critique and provider fallback across multiple LLM/VLM/image providers.

agency-orchestrator

agency-orchestrator is a TypeScript multi-agent orchestration engine that runs YAML-defined DAG workflows using prebuilt role prompts (186 roles). It can execute steps in parallel based on dependencies, pass outputs between steps via variables, and supports execution via multiple LLM providers/CLIs (including subscription-based “no API key” flows) as well as an MCP server mode for tool-calling from AI coding clients.

mcp-youtube-intelligence

Provides an MCP server (stdio-based) and CLI to extract YouTube video metadata/transcripts, generate token-optimized summaries, perform topic segmentation and entity extraction, analyze comments with sentiment, and support channel monitoring, playlist analysis, search, and batch operations. Optional LLM providers (local via Ollama/vLLM/LM Studio, or cloud via OpenAI/Anthropic/Google) power the summarization/enrichment steps with a fallback to extractive summarization.

metashape-mcp

Provides a Model Context Protocol (MCP) server embedded in Agisoft Metashape Professional (2.3+) to expose the full photogrammetry workflow—alignment, dense cloud, mesh, texture, DEM, orthomosaic, export, and network processing—as AI-callable MCP tools. Includes an optional stdio proxy for long-running operations and a local HTTP transport endpoint.

qdrant-loader

Qdrant Loader is a Python toolkit for ingesting content from multiple sources, converting and chunking documents, generating embeddings with configurable LLM providers, and loading the resulting vectors into a Qdrant vector database. It also provides an MCP server (stdio and HTTP/transport) to enable AI development tools to perform semantic and hierarchy-aware search over the indexed content.

mevzuat-mcp

mevzuat-mcp is a Python-based Model Context Protocol (MCP) server that provides LLM/agent-accessible tools for searching and retrieving Turkish legislation and related documents from mevzuat.gov.tr and bedesten.adalet.gov.tr, including full-text Markdown retrieval and within-document searches (optionally semantic).

youtube-fetcher-to-markdown

Provides a Claude Code “skill” (and a standalone Python script) that takes a YouTube URL, fetches captions/transcript and video metadata (optionally chapters/description/duration via yt-dlp), and outputs an Obsidian-ready Markdown file with YAML frontmatter (plus optional JSON/SRT exports).

zvec-mcp-server

Provides an MCP (Model Context Protocol) server exposing tools to manage a Zvec embedded vector database (collections, CRUD for documents, vector similarity search, index management) and optionally generate embeddings via OpenAI using environment-configured API credentials.

node-csfd-api

Unofficial TypeScript/JavaScript library to scrape and expose CSFD.CZ data (movie/series details, creators, user ratings, user reviews), plus optional CLI, Docker support, and an MCP server interface for LLMs.

mcp-prompt-server-go

A Go-based MCP (Model Context Protocol) server that runs over stdio and exposes a set of prompt templates as MCP “tools”, including prompt management utilities (e.g., list available prompts, reload prompt definitions) with hot-reload from a local prompts directory.

mcp-server-ccxt

Provides an MCP server that uses the Python CCXT library to fetch real-time and historical cryptocurrency market data (prices, market summaries, top volumes, OHLCV, price change stats, and volume history) from multiple exchanges.

mem0-mcp-selfhosted

Provides a self-hosted MCP server exposing mem0 memory-management tools (and optional Neo4j graph tools) for use with Claude Code, backed by Qdrant for vector search, Ollama for embeddings and optionally LLM, and optional Anthropic/OAT integration for LLM-based extraction.

ros2-engineering-skills

A SKILL.md-based knowledge module for AI coding agents that teaches production-grade ROS 2 engineering practices, including workspace setup, node/executor patterns, QoS/DDS troubleshooting, lifecycle patterns, ros2_control, Nav2, MoveIt 2, real-time considerations, security (SROS2/DDS security), testing/CI, and deployment guidance across ROS 2 distros. It also includes utility scripts for scaffolding packages, QoS compatibility checking, and launch file static validation.

video-audio-mcp

Provides an MCP (Model Context Protocol) server that exposes FFmpeg-backed tools for common video and audio editing tasks such as format conversion, trimming, resizing/aspect changes, codec/bitrate/frame-rate adjustments, overlays (text/images), subtitle burning, concatenation/transitions, and audio operations like silence removal and format/property conversion. Includes a health_check tool.

yt-dlp-mcp

Provides an MCP server (Node/TypeScript) that wraps yt-dlp to let AI agents search for videos, extract metadata, download subtitles/transcripts, and download video/audio (including trimming), via MCP tools such as ytdlp_search_videos and ytdlp_download_video/audio.

crawl4ai-mcp-server

crawl4ai-mcp-server is a self-hosted MCP server (stdio) that exposes Crawl4AI scraping/crawling capabilities to AI agents via four MCP tools: scrape, crawl, crawl_site, and crawl_sitemap. It supports Markdown extraction, BFS crawling with depth/page limits and optional adaptive stopping, and can optionally persist results to disk via output_dir/manifest files, while applying URL safety blocks for localhost/private/internal targets.

yukkit-e2b-mcp-server

Provides MCP (Model Context Protocol) server tools that let AI clients run code and manage files inside E2B sandboxes. Includes separate JavaScript/TypeScript and Python implementations, offering sandbox lifecycle management, code/command execution, filesystem operations, and optional exposure of sandbox services via public URLs.

ainativelang

AINL (AI Native Lang) is a Python-based compiler/runtime/tooling system for authoring deterministic AI workflow graphs (graph-canonical IR), validating them (strict semantics, diagnostics), and running or emitting artifacts (e.g., local runner, HTTP workers, MCP server/host integrations, and hybrid integrations such as OpenClaw/LangGraph/Temporal).

hwpx-mcp-server

Provides a local Model Context Protocol (MCP) server that uses python-hwpx to automate handling of HWPX (.hwpx) documents from AI clients (read, search, edit, extract). Includes an optional advanced toolset enabled via environment variable.

matlab-mcp-server

Provides an MCP server that lets MCP-compatible clients execute MATLAB code in a persistent session, manage MATLAB workspace variables, perform figure operations, and move data in/out (CSV/JSON/XLSX/MAT), plus access environment info and MATLAB help/toolbox metadata.

bear-notes-mcp

Provides an MCP server for Claude Desktop to read Bear note data directly from Bear’s SQLite database (read-only) and to write changes via Bear’s x-callback-url API (sync-safe) on macOS.

julia-mcp

Provides an MCP server (stdio transport) that runs Julia code in persistent Julia REPL sessions, keeping state (variables/functions/loaded packages) across tool calls and isolating sessions per environment/project directory.

python-genai

Python SDK for Google generative AI models, providing a client interface (Gemini Developer API and Vertex AI) with Pydantic/dict-based typed request/response structures and helper abstractions (e.g., model content generation, async/sync clients, file upload).

rag-mcp-server

Provides an MCP server that builds and queries a local Retrieval-Augmented Generation (RAG) knowledge base from document directories. It extracts text from .txt and .pdf files, chunks content, computes embeddings (SentenceTransformers), indexes vectors with FAISS, and stores document metadata in SQLite; exposes MCP tools for initializing, searching, refreshing, getting stats, and listing documents.

SIRIO_mcp_server

Provides a Model Context Protocol (MCP) server (Spring Boot non-web app using STDIO) exposing SIRIO/OrisTool capabilities to create and manipulate Generalized Stochastic Petri Nets (GSPNs) and run steady-state and transient analyses via MCP tool-calling.

notebooklm-mcp

Provides an MCP server that lets local AI coding agents (e.g., Claude Code, Cursor, Codex) interact with Google NotebookLM to answer questions grounded in user-owned NotebookLM notebooks, including session/library management and browser-automation-based authentication.

stim-mcp-server

Provides an MCP (Model Context Protocol) server that wraps Google’s Stim stabilizer circuit simulator, exposing multiple tools (health check, circuit creation/appending, sampling, error analysis, diagram generation, noise injection, and standard circuit generation) over MCP transports including HTTP/SSE and stdio, plus a hosted Google Cloud Run instance.

ag2

AG2 (formerly AutoGen) is an open-source Python framework for building agentic AI “agent systems”. It provides core conversational agent abstractions (e.g., ConversableAgent), support for multi-agent orchestration patterns (group chats, swarms, nested/sequential flows), tool registration/invocation (including tool use with secrets), and workflows such as human-in-the-loop supervision. It integrates with LLM providers via pluggable configuration (e.g., OpenAI) and includes optional integrations for RAG, code execution, and various retrieval backends.

video-research-mcp

video-research-mcp is a Claude Code plugin that installs and configures MCP servers to enable video understanding/analysis, deep research with evidence grading, academic/paper search and extraction, web search with citations, and an optional knowledge store (Weaviate) for persistent semantic recall. It also describes standalone MCP server usage and related explainer/video/scene-generation MCP servers.

subcog

Subcog is a persistent memory system for AI coding assistants. It captures decisions/learned context during coding sessions, stores them in SQLite (default) plus indexing (FTS5) and vector search (usearch HNSW), supports hybrid retrieval (BM25 + vector with RRF fusion), provides a knowledge-graph layer, and exposes an MCP server for agent interoperability. It also offers optional HTTP serving with JWT auth and Claude Code hook integration.

agency-swarm

Agency Swarm is a Python framework for building multi-agent (swarm) applications by defining specialized agents, tool functions (Pydantic-typed), and directional inter-agent communication flows. It is built on top of the OpenAI Agents SDK / Responses API and provides helpers for running demos and persisting thread/state.

ClawMem

ClawMem is a local-first context engine/memory for AI coding agents. It indexes markdown/project documents into a SQLite-based “vault”, performs hybrid retrieval (BM25 + vector + reranking + graph/intent-based traversal), and integrates with Claude Code via hooks + an MCP stdio server and with OpenClaw via a ContextEngine plugin or MCP tools. It also captures session decisions/handoffs and writes them back to the same local vault; it includes measures against prompt injection in surfaced content and supports deduplication, lifecycle (pin/snooze/archive), and crash-safe transaction-safe indexing.

openclaw-knowledge-distiller

Provides a Python CLI (`kd`) and an MCP server to convert video URLs (YouTube/Bilibili/Facebook) into structured knowledge outputs by extracting subtitles when available, otherwise performing local ASR (Qwen3-ASR on Apple Silicon), and optionally generating summaries via external LLM providers (Google/OpenAI/Anthropic).

space-mcp-server

An MCP server (stdio-based) that exposes NASA/space-related tools to AI agents, including APOD, NASA image search, exoplanets, space weather (DONKI), Mars rover photos/info, near-Earth objects (NeoWs), asteroid orbital details, Earth imagery (EPIC), and natural events (EONET).

vector_mcp

VectorMCP is a Ruby gem that implements the Model Context Protocol (MCP) server-side specification, providing a framework to register MCP tools, resources, prompts, and filesystem roots, and to run the server over transports such as stdio or SSE/HTTP.

ComfyUI-AnimaTool

ComfyUI-AnimaTool provides tool interfaces (MCP server, ComfyUI-compatible HTTP routes, and an optional FastAPI server/CLI) that let an AI agent generate Anima anime/illustration images via a running ComfyUI instance. It supports structured prompts, aspect ratio presets, history/reroll, and batch generation (repeat and batch_size), and includes optional LoRA injection behavior.

rlm-claude

Provides an MCP server for Claude Code that persists “infinite memory” across sessions by saving conversation chunks and extracting/saving reusable “insights”. It auto-snapshots before Claude Code’s /compact and supports search (regex, BM25, optional semantic embeddings), retention/archiving, and multi-project organization.

deep-research-mcp

An MCP (Model Context Protocol) server that performs multi-step web research using Tavily Search and Tavily Crawl, then returns structured JSON (including documentation instructions) for an LLM to generate detailed markdown documents. Optionally supports secure file writing of research outputs when explicitly enabled.

geo-lint

@ijonis/geo-lint is a Node.js/TypeScript CLI and programmatic linter for SEO + GEO (Generative Engine Optimization). It scans Markdown/MDX (and supports custom adapters for other content sources), reports structured violations as JSON (including file/field/line plus suggestion/fixStrategy), and can be used by AI agents to iteratively fix violations until the output is clean.

vmlx

vMLX is a local inference server for Apple Silicon that runs MLX-based text/vision models and provides an OpenAI/Anthropic/Ollama-compatible HTTP API (plus image generation/editing and audio STT/TTS). It also advertises MCP support via a Python dependency.

flights-mcp

A Python MCP server that searches for flight offers (one-way, round-trip, multi-city) and retrieves offer details using the Duffel flight search API. It exposes MCP tools like search_flights and get_offer_details and requires a Duffel API key provided via environment variable.

just-prompt

just-prompt is an MCP (Model Control Protocol) server that exposes a unified interface to multiple LLM providers (OpenAI, Anthropic, Google Gemini, Groq, DeepSeek, and Ollama). It provides MCP tools to send prompts to one or more models, run prompts loaded from files (optionally writing outputs to disk), list providers/models, and run a multi-model “board” workflow where a “CEO” model decides based on board member responses.

Lemonade

Local AI inference server supporting text generation (LLM), image generation, speech-to-text, and text-to-speech across CPU, GPU (Vulkan/ROCm), NPU (XDNA2), and Apple Silicon. Exposes an OpenAI-compatible REST API on localhost:8000 for drop-in integration with existing tools.

vnstock-mcp-server

Provides an unofficial MCP server exposing vnstock (Vietnam stock/finance data) functionality as MCP tools, with multiple transport options (stdio, SSE, and HTTP streaming).

anki-mcp-server

An MCP server that lets LLMs interact with local Anki flashcards by calling AnkiConnect-style operations (decks, note types, CRUD for notes, search, and related metadata) via MCP tools and resources.

borsa-mcp

Borsa MCP is a FastMCP-based remote/local MCP server that lets LLM agents query unified market and finance data for: BIST (stocks/indices), US stocks and indices (via Yahoo Finance), TEFAS funds, BtcTurk+Coinbase crypto markets, FX/commodities data, macro/TCMB data, KAP news, and provides helper tools like screeners/scanners and regulations. It exposes MCP tools to an agent through a server URL (remote) or via local installation/command.

EDDI

EDDI (Enhanced Dialog Driven Interface) is a Java/Quarkus multi-agent orchestration middleware for conversational AI. It routes conversations to one or more LLM providers, coordinates tool/API calls, and manages stateful, configurable conversation flows via a lifecycle pipeline and versioned JSON behavior rules. It can run as a Docker container (Kubernetes/OpenShift friendly) and includes built-in tools plus support for whitelisted HTTP-call tools.

hf-mcp-server

Provides an MCP server for Hugging Face Hub and Search endpoints (plus Gradio tool integration via proxying) using multiple transports (STDIO, Streamable HTTP, Streamable HTTP JSON-RPC). Includes a management web UI for configuring/adding tools and supports optional authentication/tooling for OAuth-like flows.

mcp-server-openmeteo

Provides an MCP server that exposes OpenMeteo weather capabilities as MCP tools: current weather, multi-day forecasts, historical daily weather, and global location search (geocoding) by delegating to OpenMeteo’s free public API.

chatgpt2md

CLI tool that converts ChatGPT export (ZIP or conversations.json) into organized Markdown files and builds a full-text search index (Tantivy). It also provides an MCP server (stdio transport) with tools for searching and retrieving conversations for Claude Desktop/Claude Code.

DDGS

Metasearch Python library that aggregates results from multiple search engines (Bing, Brave, DuckDuckGo, Google, Mojeek, Yandex, Yahoo, Wikipedia) into a unified interface. Supports text, image, video, news, and book searches. Includes an MCP server with HTTP and SSE transports, plus a standalone API server.

Few-Word

FewWord is a Claude Code plugin that intercepts large shell command outputs and offloads them to files on disk, replacing them in-context with compact pointers (plus small previews for failures). It also provides commands to open, search, and manage offloaded outputs and persists/archives plans via hook events.

MySearch-Proxy

MySearch-Proxy is a unified search backend for AI agents, bundling an MCP server and skills plus a deployable proxy/console. It routes queries to upstream providers (Tavily, Firecrawl, Exa, optional X/Social), manages provider health and auth errors, provides token/key/quotas syncing via the proxy layer, and offers MCP tools (search, extract_url, research, mysearch_health) accessible over stdio/HTTP/SSE.

spring-documentation-mcp-server

Provides a Spring Boot–based Model Context Protocol (MCP) server (SSE) that lets AI assistants search, browse, and retrieve full-text Spring ecosystem documentation and code examples, with automated documentation sync from spring.io and a web management UI for projects/versions and API key management.

builtwith-api

TypeScript/CLI wrapper for the BuiltWith API to look up technologies for domains/companies, retrieve lists and relationships, and support multiple response formats (JSON/XML/CSV/TSV/TXT). Includes an MCP server (separate package) exposing the same 13 methods as MCP tools.

memory-graph

MemoryGraph is an MCP server for AI coding agents that provides persistent, graph-based memory. It lets agents store “memories” (typed items with tags/importance) and create relationships between memories, then retrieve them via recall/search tools (including an “extended” profile with more complex queries and DB statistics).

claude-praetorian-mcp

Provides an MCP server (Node/TypeScript, used via npx/claude mcp) for persisting and retrieving Claude Code context “compactions” as structured, incremental TOON snapshots stored locally under each project’s .claude/praetorian directory. Includes MCP tools/commands for compacting context (with dedup/merge via Jaccard title similarity) and restoring/searching relevant saved snapshots into the active context.

ext-apps

@modelcontextprotocol/ext-apps (MCP Apps) provides an SDK/spec for extending the core MCP protocol so that MCP tools can declare interactive UI resources (e.g., charts, forms, dashboards) that chat clients render inline (typically in a sandboxed iframe) and communicate with via host-mediated messaging.

moneybird-mcp-server

An MCP (Model Context Protocol) server that lets AI assistants query and manage Moneybird bookkeeping data (contacts, invoices, accounts, products/projects, time entries) and optionally make custom Moneybird API requests, using a Moneybird API token provided via environment variables.

novyx-mcp

novyx-mcp provides a Model Context Protocol (MCP) server for persistent agent memory. It supports local operation using SQLite for core memory actions, and can connect to Novyx Cloud for an expanded feature set including audit/rollback, knowledge graph, shared context spaces, replay/tracing, evaluation, and governed/autodefense/threat-intel-related tools (depending on plan).

trading-mcp

trading-mcp is a TypeScript MCP server that exposes tools for stock screening, fundamental metrics, insider trading analysis, options put/call sentiment, and news/social sentiment analysis (via OpenAI and Reddit when configured).

granola-mcp-server

Provides an experimental MCP (Model Context Protocol) stdio server that exposes Granola.ai meeting intelligence stored in local cache files (search, metadata, transcripts, documents/notes, and cross-meeting pattern analysis) to MCP-capable clients like Claude Desktop.

xenodocs-mcp-server

xenodocs-mcp-server is an MCP server that lets an AI agent query a documentation database for up-to-date, version-specific documentation and code examples for Python (and potentially other) libraries. It exposes MCP tools to search for libraries by name and to search within a library’s docs for a query.

xiaoya-teacher-mcp-server

This package provides a Python-based MCP server for “Xiaoya” (小雅) education management, exposing tools for teacher-oriented workflows such as course resource management, question/quiz creation and management, classroom & attendance (签到) queries, and task/assignment + grading workflows. It supports multiple MCP transports (stdio by default, plus SSE and streamable HTTP). Authentication to the upstream service can be done either via account/password (with server-side token caching and automatic re-login) or via a provided Bearer token.

ynab-mcp-server

Provides an MCP (Model Context Protocol) server for YNAB that exposes the YNAB API as MCP tools, auto-generating tools from YNAB’s OpenAPI spec via FastMCP. It uses a YNAB personal access token (env var) to authenticate requests and includes support for common CRUD operations across users, budgets, accounts, categories, transactions, payees, scheduled transactions, and budget months.

damn-vulnerable-MCP-Server

An intentionally vulnerable Model Context Protocol (MCP) server and companion web tools (inspector, dashboard, exfil listener) for security training: it simulates a fictional company with multiple departmental toolsets and challenge scenarios that demonstrate common attack classes (prompt/tool injection, SQL/command/path injection, privilege escalation, data exfiltration, TOCTOU, etc.).

enrichmcp

EnrichMCP is a Python framework for building MCP (Model Context Protocol) servers that expose a semantic, type-safe data layer. It generates typed/discoverable tools from data models (e.g., SQLAlchemy models) or user-defined Pydantic schemas, supports relationships, validation, pagination, caching/context, and can serve over multiple transports (stdio by default, plus streamable HTTP).

portkey-mcp-server

Provides an MCP (Model Context Protocol) server that bridges AI tool/service integrations to Portkey, exposing MCP tools for creating prompts, rendering prompts, and listing prompts via Portkey APIs. Supports both stdio and SSE (HTTP) transports.

pyrestoolbox-mcp

Provides a local Model Context Protocol (MCP) server (FastMCP-based) that exposes ~108 reservoir engineering / petroleum engineering calculation tools by bridging AI agents (e.g., Claude Desktop) to the pyResToolbox library for tasks like PVT, well performance/IPR, nodal/VLP, DCA, material balance, geomechanics, brine properties, and related workflows.

aisuite

aisuite is a lightweight Python library that provides a unified, OpenAI-style chat completions interface across multiple LLM providers. It also offers tool-calling abstractions (manual tool handling and automatic multi-turn tool execution via max_turns) and supports Model Context Protocol (MCP) tools through an MCPClient or tool config. Providers are added via a plugin-style adapter architecture.

anki-mcp-server

Provides an MCP server (with optional local STDIO or remote HTTP mode) that lets AI assistants interact with an Anki collection via the AnkiConnect plugin—supporting sync, deck management, note CRUD, media management, and note model/template retrieval.

bonnard

Bonnard is a self-hosted, Docker-deployable semantic layer for AI agents. It provides an MCP server so agents can query governed metric definitions (cubes/views) consistently. It includes a Cube engine for query execution, a CubeStore cache for pre-aggregation, an admin UI, and a deploy API/CLI flow to push schema updates without restarting containers. A /health endpoint is available for monitoring.

Klavis

YC X25-backed platform providing 100+ pre-built MCP integrations with OAuth support for AI agents. Offers three products: Strata (intelligent connectors that optimize context window usage), MCP Integrations (pre-built connectors for services like Gmail, Slack, GitHub), and MCP Sandbox (scalable environments for LLM training and reinforcement learning). Available as cloud-hosted, self-hosted Docker, Python/TypeScript SDKs, or REST API.

langroid

Langroid is a Python multi-agent framework for building LLM-powered applications. It provides agent/task abstractions where agents collaborate via message exchange, with optional components like LLM backends, tools/functions, and vector stores, plus support for structured extraction/RAG patterns and MCP server tool adaptation.

mcp-memory-server

An MCP (Model Context Protocol) server that provides a memory storage service with tools to store, retrieve (semantic similarity), search by tags, and delete memories. It communicates via stdio (MCP over JSON-RPC transport). Storage backends include in-memory and ChromaDB; embedding models include a dummy generator and an ONNX Runtime-based embedding generator.

mcp-server-ra2-jdbc

Provides an educational Model Context Protocol (MCP) server that exposes JDBC-vanilla database operations (intended for student implementation practice) via MCP tools, backed by a Spring Boot REST layer and an H2 in-memory database.

nomik

Nomik scans a codebase and builds a persistent knowledge graph in Neo4j, then exposes code/navigation/impact and documentation capabilities to AI assistants via MCP tools (plus a local CLI and optional REST dashboard).

perplexica-mcp

Provides an MCP server (via FastMCP) that exposes a Perplexica-backed search tool to MCP clients. Supports multiple MCP transport modes: stdio, SSE, and Streamable HTTP (with Docker deployment options).

private-journal-mcp

Provides an MCP server (stdio via npx) that lets an agent write private, timestamped journal entries to local files (with YAML frontmatter) and perform local semantic search over those entries using embeddings generated with @xenova/transformers.

qdrant-llamaindex-mcp-server

Provides a Model Context Protocol (MCP) server exposing tools to read (and optionally write) documents stored in a Qdrant vector database that were indexed by LlamaIndex. It supports dynamic collection selection at runtime and attempts to adapt to various LlamaIndex payload/content field formats. For embeddings, it detects the embedding model per collection and embeds queries using a whitelisted set of allowed models, otherwise falling back to a default model.

fast-agent

fast-agent is a Python CLI-first framework for interacting with LLMs and building coding agents, workflows, and evaluation pipelines. It supports MCP servers/clients (including stdio and streamable HTTP/SSE transports), shell-mode, interactive TUI prompts, and Python agent definitions (decorator-based) that can call MCP tools and chain workflows. It also includes MCP OAuth (PKCE) integration and optional MCP ping support.

MCP-oura

An MCP (Model Context Protocol) server that exposes Oura API data via MCP tools, allowing clients to fetch sleep, readiness, and resilience data for today or for arbitrary ISO date ranges using an Oura personal access token.

mcp-server-go

mcp-server-go is a Go library for implementing an MCP (Model Context Protocol) server. It provides abstractions to define MCP tools/resources/prompts and to serve the MCP server over stdio via an implementation of the MCP protocol.

mcs-mcp

An MCP server (Go binary) that ingests Atlassian Jira board issue transition history, reconstructs workflow semantics, and serves Monte-Carlo/flow diagnostics to AI agents (e.g., forecasting completion dates, capacity/bottleneck analysis, stability/predictability via control charts).

movies-mcp-server

Movies MCP Server is an MCP (Model Context Protocol) server that manages a PostgreSQL-backed movie database, exposing tools for movie and actor CRUD, linking/unlinking cast, search (multi-criteria, by decade, by rating range), bulk import, recommendations, and director career analysis. It also provides MCP resources for returning full database stats and base64-encoded poster images.

openapi

Archived TypeScript library that converts Swagger/OpenAPI (v2.0, v3.0, v3.1) documents into type-safe schemas suitable for LLM function calling. It normalizes specs through an “emended” OpenAPI v3.1 intermediate format, and includes runtime validation (via typia integration) to validate/repair LLM-generated arguments. It also references MCP-related integration and adapters for common LLM tooling ecosystems.

roxybrowser-mcp-server

An MCP server that integrates with RoxyBrowser to manage browser instances and return Chrome DevTools Protocol (CDP) WebSocket endpoints for automation. It exposes MCP tools for workspace/browser/proxy/account management and health checks, and can be run via CLI, in-process (stdio), or used as a library for direct tool handler calls.

GPT Researcher MCP Server

MCP server wrapper around GPT Researcher that exposes deep research, quick search, report writing, and source retrieval as MCP tools. Supports STDIO, SSE, and Streamable HTTP transports for integration with Claude Desktop and other MCP clients.

ffmpeg-mcp-lite

ffmpeg-mcp-lite is an MCP server that exposes FFmpeg-based media tools to AI clients (e.g., Claude/Dive). It can get media metadata, convert formats, compress, trim, extract audio, extract frames, merge videos, and burn in subtitles.

Generative-UI-MCP

Generative-UI-MCP is an MCP server (Node/TypeScript) that provides on-demand, module-based design guidelines for AI models to generate consistent interactive visualizations (charts, diagrams, SVG illustrations, and UI mockups). It exposes an MCP tool called load_ui_guidelines and a resource snippet (generative-ui://system-prompt) for baseline widget constraints.

mcp-run-python

mcp-run-python is an MCP server that executes Python code inside a sandboxed WebAssembly environment by running Pyodide in Deno. It supports running async code, capturing stdout/stderr/return values, and provides helpers for preparing the Deno runtime/environment and for running code via an MCP stdio transport or streamable HTTP transports.

calculator-mcp

A simple Model Context Protocol calculator server

marketplace-mcp-server

An MCP server (with stdio and HTTP transports) that exposes tools for searching and retrieving package/repository metadata and assets from the Upbound Marketplace API, including support for both marketplace API v1 and v2 and UP CLI–based authentication for private resources.

Inkeep Agents

A platform for building AI agents through either a no-code visual builder or a TypeScript SDK, with bidirectional sync between both interfaces, MCP tool support, and deployment via Vercel or Docker.

lightdash_mcp

Provides an MCP (Model Context Protocol) server that connects AI assistants to Lightdash to support discovery of projects/explores/schemas, execution of queries, and CRUD-style management of charts, dashboards, tiles, and spaces—primarily via Lightdash REST endpoints using a personal access token, with optional support for auth frontends such as Cloudflare Access and Google Cloud IAP.

Audrey

Audrey is a local-first persistent memory layer for AI agents (including Claude Code). It encodes episodic events into a SQLite-backed store (with vector search via sqlite-vec), recalls relevant memories per prompt, and runs maintenance (“dream”/consolidation) to consolidate episodes into semantic/procedural knowledge with confidence decay and contradiction/validation handling. It can be used as a JS SDK, an MCP server with Claude Code memory tools, a CLI with lifecycle hooks, and a local REST API server.

ContextKeep

ContextKeep is a standalone memory server for AI agents that exposes MCP tools to store, retrieve, search, and list persistent memories. It supports local (stdio) and remote transports (SSE) plus a web dashboard for managing memories stored on the host (SQLite-backed per changelog).

frida-mcp

Provides an MCP (Model Context Protocol) stdio server that exposes Frida dynamic instrumentation capabilities (process/device management, script injection, and an interactive JS REPL) to MCP-compatible AI clients such as Claude Desktop.

MemoryMesh

MemoryMesh is a local knowledge-graph MCP server for persisting structured “memory” (nodes and edges) for AI models. It loads schema files to dynamically generate add/update/delete tools for each entity type, stores data in a local JSON memory file, and optionally provides a separate Memory Viewer web app for visualization.

my-mcp-stdio-server

A Spring Boot starter that implements an MCP (Model Context Protocol) server over STDIO transport. It registers weather-related MCP tools (forecast by latitude/longitude and alerts by US state code) backed by the National Weather Service (weather.gov) API, and provides configuration examples for running the server jar and connecting a client (including Claude Desktop).

outscraper-mcp-server

Provides an MCP (Model Context Protocol) server that exposes Outscraper-based extraction tools (e.g., Google Maps/Google/Yelp/Trustpilot/Amazon reviews and business/contact data) to MCP clients (e.g., Claude Desktop, Cursor).

semantic-router

semantic-router is a Python decision/routing layer that selects a route (e.g., intent, task, tool-use path) by embedding the incoming utterance(s) into a vector space and matching them against route utterance embeddings, returning the best-matching Route (or None if no match). It supports multiple encoder backends (e.g., OpenAI, Cohere, Hugging Face, FastEmbed, local/HF+Torch/llama-cpp) and can integrate with vector indexes such as Pinecone and Qdrant; it also advertises multimodal routing via optional vision/multimodal paths.

upstage-mcp-server

Provides an MCP server that lets an AI client (e.g., Claude Desktop) call Upstage document digitization and information extraction APIs to parse documents (PDF/images/Office files) and extract structured fields based on schemas.

codemogger

codemogger indexes local source code by parsing it with tree-sitter, chunking into semantic units, embedding chunks with a provided/local embedding pipeline, and storing vectors plus full-text search in a single embedded SQLite (.db) file; it also provides an MCP server and CLI for indexing/reindexing and searching that index.

copilot-memory-store

Provides a local JSON-backed memory store for context engineering with GitHub Copilot and MCP clients. Includes a CLI REPL to add/search/compress/delete/purge/export memories, and an MCP stdio server exposing tools and resources to let Copilot agents read/write/search memories and inject shaped/compressed context for tasks (optionally using DeepSeek for summarization/context shaping).

deepeval

deepeval is an open-source Python framework for evaluating LLM apps (e.g., chatbots, agents, RAG pipelines). It provides a test/pytest-like workflow and many ready-to-use evaluation metrics (including LLM-as-a-judge metrics such as G-Eval, RAG metrics, agent/tool metrics, multimodal metrics). Metrics can run locally (using the chosen models) and it can integrate with CI/CD and common LLM app frameworks (OpenAI, LangChain, LangGraph, LlamaIndex, CrewAI, etc.). It also offers a hosted “Confident AI” platform option with CLI login and a stated MCP server integration for persisting data/traces.

lmql

LMQL (Language Model Query Language) is a Python superset and runtime that lets you embed LLM calls directly inside code, using templated variables plus decoding algorithms and constraints (e.g., logit masking, datatype/format constraints, stopping conditions). It supports sync/async execution, multi-model backends (e.g., OpenAI, Azure OpenAI, HuggingFace Transformers), and includes tooling such as a playground and an inference API for serving models.

webclaw

webclaw is a self-hosted, local-first web scraping/extraction tool written in Rust. It fetches and extracts main content from URLs into LLM-friendly outputs (e.g., markdown/text/JSON), supports crawling and sitemap mapping, and includes an MCP server plus optional cloud API for protected/JS-heavy sites and “LLM features” (summarize/extract/search/research).

yokatlas-mcp

Provides an MCP (Model Context Protocol) server exposing Turkish Higher Education Atlas (YÖK Atlas / YOKATLAS) data via FastMCP tools, including fuzzy program search and detailed atlas statistics for associate and bachelor degree programs.

context-mode

Context Mode is an MCP-focused “context virtualization” layer for AI coding agents. It provides sandbox tools to keep large raw tool outputs out of the model context, tracks editing/tool/task/error/user events in a local SQLite database, and uses FTS5/BM25-style search to retrieve only relevant past events during context compaction so the agent can resume continuity.

knowledgebase-mcp

knowledgebase-mcp (BioContextAI) is an MCP server for biomedical research that exposes standardized MCP “tools” to let agentic LLMs query multiple biomedical knowledge sources (e.g., EuropePMC, Ensembl, InterPro, Reactome, STRING) through a unified integration layer.

mcp-logseq

Provides an MCP server that lets an AI assistant interact with your LogSeq knowledge base via LogSeq's local HTTP API. It supports reading, creating, updating, deleting pages/blocks, searching pages/content, executing Logseq DSL queries, and (optionally) semantic vector search and DB-mode property operations.

thermal-mcp-server

thermal-mcp-server is a Python-based MCP server exposing a physics/engineering model for liquid-cooled GPU thermal behavior. It estimates junction temperatures and hydraulic pressure drops, and can search for minimum coolant flow rates for a target junction temperature and compute rack-level thermal requirements for uniform GPU assumptions.

AzurePricingMCP

Provides an MCP server that lets AI assistants query Azure retail pricing, compare prices across regions/SKUs, estimate usage-based costs, and perform FinOps-oriented analyses (RI break-even, region recommendations, spot intelligence, and orphaned resource cost estimation).

Horizon

Horizon is a self-hosted (Python) AI-powered tech news aggregator that fetches items from multiple sources, deduplicates them, uses an LLM to score/filter items, enriches them with background web search, and generates bilingual (English/Chinese) daily markdown briefings that can be deployed to GitHub Pages; it also includes an MCP server so agents can drive the pipeline programmatically and an optional self-hosted email subscription flow (SMTP/IMAP).

WikidataMCP

Provides a Model Context Protocol (MCP) server exposing Wikidata exploration/query tools (item/property search, entity statements/values, hierarchy retrieval, and SPARQL execution). A hosted endpoint and local/Docker run instructions are provided.

pyomop

pyomop is a Python library/CLI for working with OHDSI OMOP CDM (v5.4/v6) databases using SQLAlchemy. It can create/init CDM tables, load OMOP vocabularies, run QueryLibrary queries, execute custom SQL and convert results to pandas DataFrames. It also includes FHIR Bulk Export (NDJSON/NDJSON) import utilities that map FHIR source values to OMOP concepts, and an optional MCP server exposing tools for database operations and query execution. There is also optional LLM-based natural-language query support via langchain extras.

bonnard-cli

CLI for deploying and querying a governed semantic/metrics layer for agentic analytics. Provides commands to scaffold projects, connect data sources, validate models, deploy with versioning/history, run queries, and set up an MCP server for governed agent queries, along with markdown dashboard tooling and programmatic access via a companion SDK/React packages.

bzm-mcp

Provides an MCP server that lets AI tools manage end-to-end BlazeMeter performance testing workflows (create/execute/report) via natural-language interactions, using BlazeMeter API credentials configured through the MCP host.

memorious-mcp

memorious-mcp is a local Model Context Protocol (MCP) server that provides semantic long-term memory operations—store, recall (vector similarity search), and forget—using ChromaDB for persistent on-disk storage.

remind

Remind (remind-mcp) is a generalized long-term memory layer for LLM-driven agents. It ingests “episodes” of experiences, consolidates them into generalized “concepts” (with confidence/conditions/exceptions), maintains an entity/knowledge graph, and supports semantic/graph-based retrieval. It can be used via a local CLI/skills workflow with a project database, or via an MCP server for IDE/desktop agents, which also exposes a web UI and a small REST API.

signing-mcp-server

Provides an offline Ethereum wallet signing toolkit with MCP servers (including signing-mcp-server) for EIP-191 message signing and EIP-712 typed-data signing/verification, plus related wallet/keystore utilities in the broader toolkit. Emphasizes offline/self-contained operation and uses established Ethereum cryptography libraries.

Autodesk-Fusion-360-MCP-Server

Provides an MCP server that bridges an AI assistant (e.g., Claude Desktop, VS Code Copilot Chat) to Autodesk Fusion 360 via an add-in, enabling tool-based generation and modification of CAD models (sketch creation, modeling operations, parameter changes, and STEP/STL export).

motion-dev-mcp

motion-dev-mcp is an MCP (Model Context Protocol) server that provides offline access to Motion.dev documentation, code examples, component/API reference, and tool-assisted animation code generation/validation for React/JavaScript/Vue. It uses a local SQLite-first documentation database with full-text search (FTS5).

openclaw-mcp

openclaw-mcp is an MCP (Model Context Protocol) server/bridge that connects Claude (MCP client) to a self-hosted OpenClaw gateway/assistant. It forwards chat/status/task operations and supports sync and async tools, including multi-instance routing and OAuth2 authentication.

qdrant-mcp-pi5

Provides a Model Context Protocol (MCP) server integration for persistent semantic memory on Raspberry Pi 5 using local Qdrant storage. Agents can store and retrieve facts via semantic similarity (embeddings) through mcporter (MCP client/bridge), optionally with an OpenClaw plugin that hard-enforces memory recall before responses.

tagny-mcp-server

Provides an MCP server (FastMCP-based) exposing tools for web search (Brave, DuckDuckGo) and web content fetching (URL visible text extraction) plus link extraction from webpages, intended for use with locally served LLMs via SSE transport.

code-reasoning

@mettamatt/code-reasoning is a local Model Context Protocol (MCP) server (TypeScript) meant to help coding-focused assistants perform structured, step-by-step “sequential thinking” for complex programming tasks. It also provides ready-to-use prompt templates/commands for MCP clients such as Claude Desktop and related tools.

Fabric-Analytics-MCP

An MCP (Model Context Protocol) server that exposes a large set of tools for authenticating to Microsoft Fabric and performing analytics/workspace operations, including CRUD for Fabric items, Spark/Livy job and monitoring workflows, and Synapse-to-Fabric migration tooling. It also supports local/Docker/Kubernetes-style deployment patterns and multiple Fabric authentication approaches.

gopher-mcp

gopher-mcp is a C++ SDK implementing the Model Context Protocol (MCP) including JSON-RPC 2.0 request/response/notification handling plus server/client helpers and a filter-chain architecture. It supports multiple transports (stdio, HTTP/SSE, HTTPS/SSE, WebSocket, TCP) and exposes a stable C API (libgopher_mcp_c) to build MCP integrations from other languages via FFI/bindings.

markupr

markupR is a local-first desktop capture tool that records screen + optionally voice/narration, aligns the transcript with captured timestamps, extracts relevant frames, enriches the report with context (cursor/app/window/focus hints when available), and outputs structured Markdown (including inline screenshots) for AI coding agents. It also provides a CLI for processing existing recordings and an MCP server for agent-driven capture/analysis workflows.

mcp-mistral-ocr

Provides an MCP server that performs OCR using Mistral AI’s OCR API. It can process files from a mounted local directory (images/PDFs) and can process files from URLs when the caller supplies an explicit file type; results are written as timestamped JSON files inside an OCR output directory under the configured OCR_DIR.

mcp-server

An MCP (Model Context Protocol) server (implemented in Go) that connects an LLM/agent to the Firebolt Data Warehouse. It exposes MCP tools for browsing Firebolt documentation, establishing Firebolt connections, executing SQL queries, and searching docs. It runs as a stdio-based MCP server by default, with optional SSE transport, and can be deployed via Docker or a binary. Authentication is done using Firebolt service-account credentials (client ID/secret) or via a Firebolt Core URL.

tigo-mcp-server

An MCP (Model Context Protocol) server that connects to a user’s Tigo Energy solar monitoring account and exposes tools for system configuration, real-time and historical production data, performance/efficiency analysis, system health/alerts, and maintenance recommendations.

brain-mcp

brain-mcp is a local (on-device) MCP server plus CLI that imports an individual’s prior AI conversations, builds embeddings/summaries (optional), and exposes cognitive “tools” for searching, reconstructing context, and analyzing thinking history.

onshape-mcp

onshape-mcp is an MCP server that exposes a set of MCP tools for programmatic interaction with Onshape (document discovery, sketch/feature/assembly creation and analysis, variable table management, FeatureScript evaluation, and exporting CAD to common formats).

PerformanceStudio

PerformanceStudio analyzes SQL Server execution plans (.sqlplan XML), flags performance issues (memory grants, estimation mismatches, spills, parallel skew, late filters, lookups, scalar UDFs, implicit conversions, anti-patterns, etc.), suggests missing indexes, and can capture actual/estimated plans from a live SQL Server. It provides both CLI/JSON outputs for automation and a desktop GUI. It also includes an opt-in built-in MCP server to let LLM clients analyze loaded plans and Query Store data.

powerbi-mcp

A Model Context Protocol (MCP) server that lets AI assistants interact with Microsoft Power BI Desktop and Power BI Service to inspect semantic models, run DAX, test Row-Level Security, and perform safe model/report modifications (notably via PBIP file editing for renames).

qlik-sense-mcp-server

An MCP server that exposes a unified set of tools for interacting with Qlik Sense Enterprise Repository and Engine APIs, including application discovery, metadata inspection, script extraction, field/variable retrieval with pagination/search, and an operation to create a hypercube for analytics.

scitex-python

scitex (SciTeX) is a Python toolkit and orchestration layer for scientific research workflows: experiment tracking/session management, unified file I/O, reproducible figure generation (via figrecipe), statistical testing, literature management (scholar), LaTeX manuscript compilation (writer), and cryptographic verification/provenance tracking (clew). It also exposes an MCP server surface (named scitex) with a large set of MCP tools intended for AI agents to run parts of the research lifecycle via structured tool calls.

ai-counsel

AI Counsel is a self-hostable MCP server that runs multi-participant, multi-round “deliberation” among AI models to debate, cast structured votes with confidence/rationale, and converge on a decision. It can optionally ground decisions using evidence-based tools (read/search/list/run safe commands) against a provided working directory, includes transcript/audit outputs, and can reuse context via semantic retrieval of past debates.

cursor-feedback-extension

Cursor Feedback is a Cursor IDE extension plus an MCP server that provides an interactive human-in-the-loop feedback step. The Cursor AI agent calls an MCP tool (interactive_feedback), the extension shows a sidebar UI to collect user feedback (text/images/files), and the MCP server returns the feedback to the agent so it can continue within the same conversation.

MCP-Bridge

Middleware that bridges the OpenAI API with MCP tools, allowing developers to expose MCP tool capabilities through an OpenAI-compatible API endpoint. Supports streaming and non-streaming chat completions with MCP tool calls, SSE bridge for external clients, REST API endpoints for MCP primitives, and optional API key authentication.

mem0-mcp

Provides an MCP server exposing tools (add_memory, search_memory, delete_memory) backed by Mem0 for long-term memory storage and retrieval across LLM sessions. Supports three modes: Mem0 cloud, Supabase (self-host), and local/in-memory (dev).

nitrostack

NitroStack is a TypeScript framework/CLI for building production-ready Model Context Protocol (MCP) servers and AI-native backend apps. It provides decorator-driven tool definitions, dependency injection, authentication (JWT/OAuth2.1/API keys), middleware/guards/interceptors, validation via Zod, and a development/testing workflow (including NitroStudio and a widgets/UI layer for tool outputs).

real-estate-data-mcp-server

Provides an MCP server with tools to query public US real-estate related data (housing stats, demographics, nearby amenities, comparisons, cost-of-living/affordability) using US Census ACS and OpenStreetMap (Nominatim/Overpass).

sift-gateway

Sift is a reliability gateway that captures JSON outputs from upstream MCP/CLI tools, persists them as SQLite artifacts, redacts secrets on the way back to the model, and returns either inline JSON (`full`) or stable schema-based references (`schema_ref`) for follow-up. It provides explicit pagination continuation until completion and a Python-based artifact querying interface for exact retrieval across one artifact or an entire pagination chain.

trading_skills

Trading_skills provides an AI-assisted interface (Claude Code/Cursor integration and a Claude Desktop MCP server) for market and options analysis. It pulls market data (Yahoo Finance) for quotes/history/fundamentals/news/earnings and computes technical indicators, option Greeks, spread analysis, and risk metrics; it can also connect to Interactive Brokers via TWS/IB Gateway to summarize a portfolio and generate event/earnings-aware action reports and option roll candidates (per README descriptions).

apple-health-mcp

Provides an MCP server (usable via npx) that lets an MCP client query locally exported Apple Health data from CSV files using natural-language-to-SQL plus direct SQL execution, with schema introspection and automated health reporting. Uses DuckDB for in-process analytics, with lazy loading by time windows and result caching via TTL.

FreeCAD-MCP

FreeCAD-MCP is a FreeCAD workbench/plugin that exposes FreeCAD automation capabilities through the Model Context Protocol (MCP). It includes an MCP server with a GUI control panel, plus a Python client that can create/update/validate/run FreeCAD macros (FCMacro), adjust 3D views, and retrieve execution logs/reports. Communication is via stdio or TCP and integrates macro normalization (imports, recompute, view adjustment) before running.

MCP-Nest

A NestJS module for building and exposing Model Context Protocol (MCP) servers that map NestJS methods to MCP tools (with Zod validation), plus MCP resources and prompt templates. It supports multiple transports (HTTP+SSE, Streamable HTTP, STDIO) and offers guard-based and built-in/external authorization patterns (including OAuth).

openfoodfacts-mcp-server

Provides an MCP server for querying the Open Food Facts product dataset. It downloads/caches a Parquet product database and uses DuckDB for fast search, exposing MCP tools for brand/name lookup and barcode lookup. Supports local STDIO (Claude Desktop) mode without auth and remote HTTP mode with Bearer-token auth (except /health).

publicdotcom-mcp-server

Provides an MCP (Model Context Protocol) server exposing Public.com brokerage/trading API operations as MCP tools (read-only and write/destructive actions) over stdio for AI assistants.

rl

TorchRL (torchrl) is an open-source, Python-first reinforcement learning library built for PyTorch. It provides modular RL building blocks (environments/wrappers, collectors, replay buffers, losses/models, trainers/algorithms) and also includes an LLM/RLHF-oriented API (e.g., chat/history utilities, LLM wrappers/backends like vLLM/SGLang, and LLM objectives such as GRPO/SFT).

Upsonic

Upsonic is a Python agent framework for building production-oriented LLM agents. It supports multiple model providers (e.g., OpenAI/Anthropic/Azure/Bedrock), tool integration (including MCP and custom tools), OCR/document processing, memory/state management, multi-agent coordination, and a safety engine with policy-based content handling.

zotero-mcp-server

Provides an MCP server that connects a user's Zotero library to AI assistants, enabling semantic/keyword search, retrieval of item metadata/full text/attachments and annotations, and write operations (e.g., add items by DOI/URL/file, manage collections/tags/notes). Supports local Zotero access, web API access, and an MCP transport option (stdio/streamable-http/sse). Optional extras add semantic search embeddings, PDF outline/annotation extraction, and Scite citation intelligence.

claw-compactor

Claw Compactor is an open-source Python library/CLI that compresses LLM input text and workspace content using a 14-stage, content-aware “Fusion Pipeline.” It focuses on reversible compression (via marker-based rewind retrieval) and AST-aware code compression (tree-sitter when available), aiming to reduce token counts and estimated inference cost without using external LLM inference for the compression itself.

Cognio

Cognio is an MCP server and local REST API for storing persistent semantic memories in a SQLite database, enabling semantic (and optional hybrid) search across conversations/projects. It also exposes MCP tools for memory CRUD, project management, stats, export, and text summarization, plus a local web UI dashboard.

meGPT

meGPT is a Python repository for ingesting an author’s public content (books, blog posts, social archives, YouTube, podcasts, etc.), preprocessing it (downloading/extracting/transcribing/summarizing/deduplicating), and exposing the resulting knowledge base via a Model Context Protocol (MCP) server for AI apps to search and retrieve content in an “author voice”/persona style.

vllm-mcp-server

vLLM MCP server that exposes vLLM chat/completions plus model and status/metrics capabilities to MCP-compatible clients. It can also start/stop/manage a vLLM instance in Docker/Podman with platform/GPU-aware container selection and runtime configuration via environment variables and MCP tools.

alphavantage

Provides a Model Context Protocol (MCP) server that exposes Alpha Vantage stock/market data as MCP tools. Can run as an stdio MCP server (default) or as an HTTP “streamable” MCP server, with optional OAuth 2.1 protection for the HTTP mode. Uses an Alpha Vantage API key via environment variable `ALPHAVANTAGE_API_KEY`.

perfetto-mcp

perfetto-mcp is a local Model Context Protocol (MCP) server that turns natural-language prompts into Perfetto trace analyses (including generating PerfettoSQL) for tasks like jank/ANR detection, CPU hotspot analysis, lock contention, Binder transaction profiling, and memory leak signals.

protocols-io-mcp-server

Provides a Python MCP server for interacting with protocols.io data and performing basic protocol/step CRUD via MCP tools. Supports stdio transport by default and HTTP/SSE transports, with credentials for protocols.io API (token-based or OAuth2 client credentials).

reaper-mcp

reaper-mcp-server is a local Model Context Protocol (MCP) server that exposes REAPER DAW functionality (project management, track/MIDI/Fx/audio operations, mixing/mastering, rendering, and audio analysis) to AI agents, using python-reapy with REAPER’s distant API enabled.

AutoResearchClaw

AutoResearchClaw is a Python-based autonomous research pipeline that takes a user’s research topic/idea and generates a conference-ready paper end-to-end (scoping, literature discovery/collection, synthesis, experiment design/execution in sandbox, analysis/decision loops, paper writing in LaTeX, and citation verification). It can be run via a CLI, used programmatically via a Python API, or integrated through OpenClaw/ACP-compatible agent backends, including a bridge for messaging platforms and scheduled runs.

memora

Memora is a lightweight MCP-compatible memory server that provides persistent semantic memory storage (SQLite with optional cloud sync), knowledge-graph linking, and a graph UI. It supports embeddings-based semantic search, RAG chat with tool calling, and LLM-assisted deduplication/merge workflows.

superset-mcp

Provides an MCP server that lets AI agents interact with an Apache Superset instance (manage dashboards/charts/datasets/tags and run/inspect SQL Lab queries) via a set of MCP tools.

youtube-mcp-server

Provides a Model Context Protocol (MCP) server that lets an MCP host query YouTube for video search, video details, thumbnails, transcripts, and various channel/playlist metadata (including comments/activities limited to public data).

aleph

Aleph is a Python MCP server and CLI/skill that implements a Recursive Language Model (RLM) workflow: it persists working state (loaded contexts, search indexes, evidence, sessions) outside the LLM prompt window, supports iterative search/navigation, server-side code execution over loaded context (exec_python), and recursive sub-query orchestration to converge on answers.

docmole

Docmole is an MCP server that helps AI assistants query documentation sites. It supports a local RAG mode (crawl docs, generate embeddings with OpenAI, store/search in LanceDB) and a Mintlify mode (proxy to Mintlify’s assistant API for certain Mintlify-powered documentation sites). It also provides a CLI to set up projects, serve/stop them, and list available projects.

gcp-cost-mcp-server

Provides an MCP server with tools to estimate Google Cloud (GCP) running costs by querying Google Cloud Billing Catalog API for SKUs/pricing and (separately) fetching free-tier information from GCP documentation, then calculating estimated monthly costs with automatic free-tier deduction.

golang-mcp-server-sdk

A Go SDK to build MCP (Model Context Protocol) servers, letting developers expose MCP tools, resources, and prompts over multiple transports (stdio and HTTP with SSE), while handling MCP protocol message routing and lifecycle in accordance with the MCP specification.

mcp-servers-for-revit

Provides an MCP server (TypeScript) and a Revit add-in (C#) that bridge MCP tool calls from AI clients into Revit actions (read, create, modify, delete elements; also supports exporting/storing some project data).

mcp-webmvc-server

A Spring Boot sample MCP server that exposes weather-related tools (forecast by lat/long and alerts by US state) via the Spring AI MCP Server WebMVC transport. It can run over HTTP SSE (default) or over STDIO for MCP clients.

studio

Studio (Deco CMS) is an open-source control plane for AI agents. It lets you hire/compose agents, connect and govern external tools via MCP (including “Virtual MCPs”), organize agents and tool connections into projects, and provides observability for tokens/costs/latency/errors. It can run locally with embedded PostgreSQL or via a cloud/team mode.

toolhive-registry-server

Provides a standards-compliant MCP Registry Server with a central registry catalog and an Admin API for managing sources/registries/entries. It supports multiple backend data sources (API/Git/File/Managed/Kubernetes) and optional PostgreSQL storage, with OAuth/OIDC-based enterprise auth support.

Unity-AI-Animation

Unity editor tooling that exposes MCP “tools” to create and modify Unity AnimationClips and AnimatorControllers (e.g., create/get/modify .anim and .controller assets) via natural-language commands, built on top of the “AI Game Developer” Unity-MCP platform.

w3-mcp-server-qdrant

Provides a Python MCP server exposing tools to query a Qdrant vector database using text queries. It can auto-generate embeddings via an external Ollama server and supports advanced retrieval techniques such as query expansion (with RRF merging), HyDE, and LLM-based reranking.

chessmata

Chessmata is a multiplayer chess platform with a browser 3D frontend, a WebSocket-based real-time game/matchmaking system, and programmatic access via both a REST API and an MCP server for AI agent tool-calling workflows. It includes a Python CLI with an MCP server and a UCI adapter to integrate existing UCI chess engines.

graphrag_mcp

Provides an MCP (Model Context Protocol) server exposing tools/resources that query a hybrid GraphRAG datastore: Neo4j for graph-based context expansion and Qdrant for vector/semantic search, with hybrid retrieval combining both.

obsidian-mcp-plugin

Provides an MCP (Model Context Protocol) server for Obsidian that exposes semantic, graph-aware tools for an AI assistant to read, search, and modify content in an Obsidian vault over HTTP transport (optionally with HTTPS).

perplexity-mcp

Provides an MCP (Model Context Protocol) server that exposes a single web-search tool backed by Perplexity AI’s API, intended for use with Claude Desktop (and similar MCP clients).

prisma-cloud-docs-mcp-server

Provides an MCP server (with both STDIO and HTTP/container modes) that indexes and searches Prisma Cloud documentation and API references via MCP tools such as indexing, searching, and checking index/cache status.

UnityMCP

UnityMCP provides an integration framework that connects an external AI client (via MCP) to a Unity Editor project. It includes a TypeScript MCP server/client component and a C# Unity Editor plugin that routes MCP tool/resource/prompt calls over TCP to Unity, where extensible command/resource handlers are auto-discovered and executed.

aura

Aura is a Rust framework that composes and runs AI agents from declarative TOML configuration. It provides an OpenAI-compatible HTTP/SSE web API for chat/completions, integrates with multiple LLM providers, supports dynamic MCP tool discovery via multiple transports (HTTP/SSE/stdio), and includes optional RAG/vector store pipelines and OpenTelemetry-based observability.

mcp-products-server

mcp-products-server is a Model Context Protocol (MCP) server that exposes product-search and product-marketing-summary tools over JSON-RPC/HTTP. It integrates with Azure Cosmos DB for vector/full-text search and for storing/retrieving/updating/deleting marketing summaries, and can optionally use Azure OpenAI for AI-generated summary content. A Blazor client app is included for interactive testing and visibility into tool invocations.

AgentRunKit

AgentRunKit is a lightweight Swift 6 framework for building LLM-powered agents with type-safe tool calling, streaming, context management/compaction, structured outputs, multimodal support, and an MCP client (stdio/JSON-RPC). It supports both cloud providers (e.g., OpenAI-compatible, Anthropic, Gemini, Vertex) and on-device inference via MLX and Apple Foundation Models.

godot-mcp-docs

Provides an MCP server (via a Docker image) that exposes the official Godot Engine documentation to AI assistants, including a documentation tree and retrieval of specific files such as class docs and tutorials.

google-news-trends-mcp

Provides an MCP server plus CLI to fetch and return structured data derived from Google News RSS feeds (by keyword/location/topic/top news) and Google Trends (trending keywords by geo). Optionally summarizes/condenses articles using LLM/NLP pipelines.

mcp-stytch-consumer-todo-list

Provides a Cloudflare Workers full-stack demo app (React static site + REST API + MCP server) where user/client identity and authentication flows are handled by Stytch, and TODO data is stored in Workers KV / Durable Objects.

notebooklm-skill

notebooklm-skill bridges NotebookLM research with Claude-style content generation and distribution. It ingests URLs/PDFs/trending topics, creates and manages NotebookLM notebooks, runs deep research/QA with citations, generates multiple artifact types (text and downloadable assets like audio/video/slides/reports and some structured outputs), and can run as a CLI tool, a Claude Code Skill, or an MCP server for agent-driven workflows.

3dsmax-mcp

An MCP server that allows AI agents to inspect and manipulate Autodesk 3ds Max scenes via a FastMCP (Python/stdio) server bridged to 3ds Max through a native C++ Global Utility Plugin (named pipes) or, as a fallback, a MAXScript TCP listener on port 8765.

gram

Gram is an MCP Cloud Platform and TypeScript framework for creating, curating, and hosting Model Context Protocol (MCP) servers. It supports defining tools via OpenAPI documents and via custom TypeScript “Gram Functions,” and provides a CLI and hosted control plane (gram app) for managing MCP servers/tool sources, including OAuth support.

local-skills-mcp

Provides a local MCP server that exposes filesystem-based “skills” (SKILL.md files) to any MCP-compatible LLM/agent client. It aggregates skills from multiple default directories and a custom SKILLS_DIR, supports lazy loading (names/descriptions first, full content on-demand), and hot reloads changes without restarting.

open-ontologies

Open Ontologies is a local Rust-based AI-native ontology engine and MCP server that builds, validates, reasons over, queries, diffs/lints, version-controls, and persists RDF/OWL ontologies using an in-memory Oxigraph triple store (plus OWL2-DL tableaux reasoning and SHACL validation). It also ships a desktop Studio UI that orchestrates tool calls via an MCP-connected agent.

run-model-context-protocol-servers-with-aws-lambda

Wraps existing Model Context Protocol (MCP) stdio-based servers so they can run inside AWS Lambda and be exposed to MCP clients via streamable HTTP (e.g., API Gateway or Bedrock AgentCore Gateway) or via Lambda function URL / direct Lambda invocation using AWS IAM authentication.

vllm-mlx

vLLM-MLX is an Apple Silicon (MLX/Metal) inference server that exposes OpenAI-compatible chat/completions, Anthropic-compatible messages, and OpenAI-compatible embeddings. It supports multimodal (text+image/video, and audio via optional deps), continuous batching, and MCP tool calling.

yoktez-mcp

Provides an MCP (FastMCP) server that lets MCP-capable LLM clients search the Turkish YÖK National Thesis (Ulusal Tez Merkezi) database and fetch thesis PDF content converted to Markdown by PDF page. Also extracts/returns thesis metadata from detail pages.

mcp2py

mcp2py turns MCP (Model Context Protocol) servers into Python modules by spawning/connecting to an MCP server and exposing MCP tools/resources/prompts as Python methods/attributes/template helpers. It also supports interactive server flows (elicitation), and can handle LLM sampling for servers using Anthropic/OpenAI via LiteLLM (or a custom sampling handler).

mcp-rdf-explorer

mcp-rdf-explorer is an MCP (Model Context Protocol) server that lets AI clients explore RDF data using FastMCP tools/resources. It supports RDF Turtle local-file mode and SPARQL endpoint mode, providing SPARQL execution utilities, graph statistics, schema/resource discovery, and some prompt-to-SPARQL style capabilities.

mcp-server-ai

A Go-based multi-protocol (HTTP/REST, gRPC, WebSocket, SSE) AI gateway/MCP server that unifies access to multiple LLM providers (notably AWS Bedrock and Azure OpenAI) behind a consistent API, including worker-pool parallelism, streaming, sessions, Redis/PostgreSQL persistence, and observability (Prometheus/Grafana/Jaeger).

short-video-maker

Self-hostable tool that generates short-form videos from text by producing TTS audio, auto-captions, selecting background videos (via Pexels), composing the result with Remotion, and rendering the final short video. Exposes both an MCP server (SSE/messages) and a REST API for creating videos and checking status.

FinanceToolkit

FinanceToolkit is an open-source Python library for transparent financial analysis. It fetches historical market data and financial statements (primarily via Financial Modeling Prep, with fallback to Yahoo Finance unless enforced), and computes a wide set of financial ratios, models, technical indicators, options analytics/Greeks, performance metrics, and risk metrics (e.g., Sharpe ratio, Value at Risk).

sdk-python

A Python SDK for building and running AI agents using a model-driven approach. It provides an agent loop, tool integrations (Python-decorated tools and optional built-in tools), support for multiple model providers (including OpenAI, Anthropic, Gemini, Bedrock, and others), streaming (including experimental bidirectional streaming), and native Model Context Protocol (MCP) client support for connecting to MCP servers.

serpstat-mcp-server-java

A Java MCP (Model Context Protocol) server that wraps the Serpstat Public API to provide SEO analysis tools (domain info, keywords, competitors, backlinks, related keywords, and API usage stats) to MCP clients such as Claude Desktop. It is configured via an API token provided as an environment variable and runs as a local proxy/listening MCP server process.

youtube-mcp-server

Provides an MCP server over SSE that lets AI agents extract YouTube video metadata (via yt-dlp) and generate audio transcriptions using VAD (Silero VAD) and Whisper, with caching and configurable performance settings.

fabric-mcp

Provides a standalone MCP server that bridges MCP tool calls to a running Fabric AI instance (via its REST API), exposing tools for listing patterns/models and running Fabric patterns/configurations.

freecad-mcp

Provides an MCP (Model Context Protocol) server/bridge to control FreeCAD for CAD automation via AI-driven natural-language commands (e.g., creating/modifying 3D models and taking screenshots).

google-ads-analyzer

Provides a local MCP server that connects to the Google Ads API, exposing read tools (GAQL search, list accessible customer IDs) and additional write tools (add negative keywords, pause/enable campaigns, update campaign budgets, change bidding strategies, and pause/enable ad groups/ads) so an LLM/agent can analyze and manage Google Ads accounts.

mcp-memory-libsql

Provides an MCP server implementing a persistent memory/knowledge store backed by libSQL (local SQLite or remote libSQL). It supports entity CRUD, relation management, and text search (including relevance ranking and fuzzy matching) over stored entity data/observations.

roampal-core

roampal-core is a Python MCP server plus a local HTTP hook/service that injects relevant long-term and outcome-scored memory into AI coding assistants (Claude Code and OpenCode). It also scores prior exchanges, promotes good advice, demotes bad advice, and supports ingesting reference documents for retrieval via semantic search across multiple memory collections.

strands-mcp-server

Provides an MCP server and client integration for Strands Agents, exposing agent tools to MCP-compatible clients (via HTTP or stdio) and allowing Strands agents to connect to remote MCP servers. Includes a CLI for running locally or proxying to an upstream MCP server.

thoughtful-claude

A Python MCP server intended to route Claude tool calls to DeepSeek's reasoning model (DeepSeek R1) to provide enhanced multi-step reasoning, with streaming support and wrapping of returned reasoning in <ant_thinking> tags.

ultimate_mcp_client

ultimate_mcp_client is an asynchronous Python client for the Model Context Protocol (MCP) that connects AI clients to MCP servers over multiple transports (stdio, SSE, streaming-http). It provides an interactive CLI and a reactive web UI, including server discovery/management, robust stdio handling, streaming of model output and tool interactions, conversation branching with persistence, optional caching, and observability via OpenTelemetry.

webmcp-react

Provides React hooks/components (<WebMCPProvider>, useMcpTool) that expose typed tools to WebMCP via navigator.modelContext in a transport-agnostic, SSR-safe way. It uses Zod-first tool input definitions with optional JSON Schema fallback, and includes a polyfill for environments without native WebMCP. Tools can dynamically register/unregister with React lifecycle and supports annotations and execution state via the hook.

yargi-mcp

Provides a Model Context Protocol (MCP) server for accessing Turkish legal/decision sources (e.g., Yargıtay, Danıştay, Uyuşmazlık Mahkemesi, Anayasa Mahkemesi, KİK, Rekabet Kurumu, Sayıştay, KVKK, BDDK, Sigorta Tahkim) with searchable tools and document retrieval (mostly returned as Markdown, with some pagination/long-text chunking). It can be used remotely via a hosted FastMCP endpoint or run locally via a Python/uv entrypoint.

zotero-mcp

A Model Context Protocol (MCP) server that exposes a small set of Zotero tools to AI assistants/clients: search for Zotero items, fetch item metadata, and retrieve full text (PDF/fulltext) for items. It can connect either to the Zotero desktop app’s local API or the Zotero Web API using an API key and library ID.

coremltools

coremltools is a Python library that converts and manipulates machine-learning models into Apple Core ML format, including reading/writing/optimizing Core ML models and (on macOS) verifying conversions via prediction.

robotmem

robotmem is a persistent memory system for robotic/agent experiences. It records episodic robot experience (parameters/strategies/trajectories/outcomes), stores perception data, and retrieves relevant past memories using hybrid search (BM25 + vector) with structured JSON filtering and optional spatial nearest-neighbor sorting. It can also run as an MCP server (7 tools) or be used directly via Python imports, with an embedded local SQLite database.

CoexistAI

Modular research assistant framework that combines multiple data sources (web search, Reddit, YouTube, maps, git repos, local files) into unified workflows. Provides FastAPI endpoints for each data source, supports multiple LLM providers (Gemini, OpenAI, Groq, Ollama), includes text-to-podcast and text-to-speech generation, and offers MCP protocol support for agent integration.

excalidraw-mcp

Model Context Protocol server for Excalidraw diagrams.

mcp-boilerplate

Boilerplate for building a remote MCP server on Cloudflare Workers that provides user authentication (Google or GitHub via OAuth) and Stripe-based monetization (free vs paid tools, including subscription and other billing modes). It exposes an SSE endpoint for the MCP tooling and includes example tool implementations using Zod and Stripe’s MCP/Cloudflare agent toolkit.

tally-mcp-server-by-cdata

Provides a read-only Model Context Protocol (MCP) server that exposes Tally data as SQL-like relational models via CData’s JDBC Driver, enabling an MCP-capable client (e.g., Claude Desktop) to query live Tally data without writing SQL manually.

weather-mcp-server

weather-mcp-server is a Model Context Protocol (MCP) server for Claude Desktop that provides weather data (current conditions, 5-day forecast, and query history) by integrating with OpenWeatherMap and using PostgreSQL and Redis for persistence and caching.

codectx

codectx is a Python CLI that scans a source repository, ranks files by importance, extracts AST-derived structured summaries (via tree-sitter), enforces a token budget, and emits a single Markdown context document (e.g., CONTEXT.md) intended to be immediately useful to LLM agents.

google-ad-manager-mcp-server-by-cdata

Provides a read-only MCP server that exposes Google Ad Manager data via CData’s JDBC Driver (as SQL-accessible relational models) to MCP-capable clients (e.g., Claude Desktop). It runs as a local stdio MCP server, using a .prp file to configure the JDBC driver and connection string.

instagram-mcp-server-by-cdata

Provides a local, read-oriented MCP Server that exposes Instagram data as relational tables via CData’s JDBC Driver, wrapped behind a small MCP tool surface (get tables/columns and run SELECT queries) for LLM clients such as Claude Desktop.

ogham-mcp

Ogham MCP is a Python-based Model Context Protocol (MCP) server that provides persistent, cross-client “shared memory” for AI coding agents. It stores memories in a Postgres-compatible database (Supabase/Postgres), generates embeddings via configurable providers (OpenAI/Ollama/Mistral/Voyage/Gemini or local ONNX), and exposes MCP tools for memory storage/retrieval plus additional capabilities like search, graph/profiles, and import/export. It can run per-client in stdio mode or as a shared persistent server via SSE transport, and includes CLI utilities (init/health/search/store/list/export/import/serve/openapi).

binja-lattice-mcp

Provides a Binary Ninja plugin and MCP server bridge that lets clients query binary analysis data (functions, disassembly/pseudocode, types, tags, progress, strings/bytes/search) and also modify the active Binary Ninja database (rename functions/variables, add comments, set types/signatures, create structs/tags) over an HTTP/REST interface exposed to an MCP server/client workflow.

broker-as-a-service

Provides a remote MCP server (Streamable HTTP) that lets AI agents discover assets, obtain swap quotes, start cross-chain swaps (including DCA), and track swap status via a swap ID using Chainflip’s decentralized exchange.

Deep Research

Self-hosted deep research tool that generates comprehensive research reports in about 2 minutes using configurable thinking and task LLM models. Combines multiple LLM providers (OpenAI, Anthropic, Google, Deepseek, Mistral, Ollama, etc.) with multiple search providers (Tavily, Searxng, Brave, Exa, Firecrawl). Includes MCP server support, knowledge graph generation, research history, and a multi-language web UI.

gemini-mcp-tool

An MCP server that exposes tools/commands to let AI assistants call the Gemini CLI (via an MCP client such as Claude Code/Claude Desktop) for natural-language analysis and file/codebase understanding, including a sandbox mode for safer code execution/testing.

MCP Client for Ollama (ollmcp)

Terminal-based MCP client that connects local Ollama language models to MCP servers. Supports agent mode with iterative tool execution, multi-server connections, STDIO/SSE/Streamable HTTP transports, MCP prompts, human-in-the-loop tool approval, thinking mode, and conversation history export. This is a CLIENT, not an MCP server.

penpot-mcp

Provides Penpot’s official Model Context Protocol (MCP) server and an accompanying Penpot plugin. The MCP server exposes tools that let an AI client retrieve, transform, and create design elements in a Penpot design file by routing requests through a WebSocket-connected Penpot plugin.

produckai-mcp-server

Provides an MCP server that lets Claude Desktop ingest customer feedback from sources (Slack, Google Drive, Zoom, JIRA, CSV/manual), run AI analysis (clustering/insights/embeddings), score feedback using VOC dimensions, and generate/export evidence-backed PRDs with JIRA sync support.

Unity-AI-ParticleSystem

Unity editor/MCP-oriented plugin that enables inspecting and modifying Unity ParticleSystem components via natural-language commands. It exposes MCP tools to get ParticleSystem data and to modify ParticleSystem modules/properties (24 supported modules).

unity-mcp-pro-plugin

Unity editor plugin that integrates MCP-compatible AI assistants with the Unity editor by running a WebSocket client inside Unity and dispatching tool calls to Unity-side command handlers (with Undo/Redo and reconnection handling).

AllVoiceLab-MCP

AllVoiceLab-MCP is an MCP server that exposes tools for text-to-speech, voice conversion, voice cloning, video translation/dubbing, subtitles extraction, and subtitle removal by calling AllVoiceLab’s underlying TTS/VC/video translation APIs.

llm

llm is a Python library and command-line tool for interacting with large language models (both via remote APIs like OpenAI/Anthropic/Gemini and via locally installed/self-hosted models through plugins). It supports running prompts from the CLI, managing API keys, chat, embeddings, structured extraction (schemas), tool execution, and logging to SQLite.

owl

OWL is an open-source Python multi-agent framework built on top of CAMEL-AI to orchestrate collaborative agent workflows for real-world task automation. It supports tool use across many domains (e.g., online search, browser automation via Playwright, document parsing, multimodal analysis, code execution) and integrates Model Context Protocol (MCP) tool calling plus additional toolkits (including MCP toolkits, file/terminal capabilities, and various domain-specific toolkits).

patent-intelligence-mcp-server

Provides an MCP server with multiple tools for searching and analyzing US patent data using the free USPTO PatentsView API (e.g., search, patent details, citations, technology trends, CPC/IPC classification search, families, claim extraction, top holders, portfolio comparison, and landscape/strategic analysis).

skills

The microsoft/skills repository provides a curated catalog of “agent skills” (copy/installable templates) and related assets (custom agents/AGENTS.md templates and MCP configurations) aimed at AI coding agents working with Azure SDKs and Microsoft AI Foundry. It includes a “skills.sh” installer/wizard, plus a “mcp-builder” skill to help create MCP servers for LLM tool integration.

snapchat-ads-mcp-server-by-cdata

Provides a local, read-only Model Context Protocol (MCP) server that exposes Snapchat Ads data to AI clients by wrapping a CData JDBC Driver connection as MCP tools (get tables, get columns, run SELECT queries).

spring-boot-ai-mcp-server

Provides a Spring Boot implementation of an MCP (Model Context Protocol) server exposing crypto/news-related tools (search/get latest news, token tracking, sentiment analysis) over HTTP (JSON-RPC) and SSE transports, with SQLite persistence and Caffeine caching.

trae-agent

Trae Agent (trae-cli) is a Python CLI framework for LLM-based, general-purpose software engineering tasks. It runs an agent loop with a configurable tool ecosystem (e.g., file editing and bash execution), supports multiple LLM providers, can record detailed trajectories for debugging, and optionally integrates MCP servers for additional tool/model context.

tuui

TUUI is a desktop “local AI playground” client built around the Model Context Protocol (MCP). It can connect to different LLM backends (including hosted APIs) and manage MCP servers to provide tools/prompts/resources and related MCP client features. It also supports discovery/registry and (via configuration) running local or remote MCP servers (e.g., Cloudflare mcp-remote).

zeromcp

zeromcp is a minimal, zero-dependency (stdlib-only) Python implementation of the Model Context Protocol (MCP) that lets you expose typed Python functions as MCP tools/resources/prompts, and serve them over HTTP/SSE or over stdio.

deer-flow

DeerFlow (2.0) is an open-source long-horizon “super agent” harness that orchestrates sub-agents, memory, and sandboxed execution to perform complex tasks over minutes to hours, with extensible skills/tools and support for configurable model providers (Python/Node ecosystem) and integrations like MCP servers and messaging (IM) channels.

garmin_mcp

An MCP server that connects to Garmin Connect (via the python-garminconnect library) and exposes fitness/health data and related operations as a large set of MCP tools for MCP-compatible clients (e.g., Claude Desktop). Includes an auth CLI to pre-authenticate and persist OAuth tokens for MFA and subsequent use.

hive

Hive is a Python runtime harness for AI agents in production. It supports goal-driven agent development (a coding “queen” generates an agent graph/code), then executes that graph with features like state isolation, checkpoint-based crash recovery, cost enforcement/degradation, real-time observability via streaming, and human-in-the-loop pause/intervention nodes. It also advertises integration through MCP tools and tool/agent SDK-wrapped nodes, with support for multiple LLM providers via LiteLLM-compatible interfaces.

ibm-db2-mcp-server-by-cdata

Provides a read-only MCP (Model Context Protocol) server that exposes IBM DB2 data to local AI clients via CData JDBC Driver. It runs as a stdio-based MCP server and offers tools to list tables/columns and execute SQL SELECT queries against DB2 without requiring end users to write SQL.

knowledge-mcp

knowledge-mcp is a Python MCP server plus CLI for creating, managing, and querying local knowledge bases backed by LightRAG (hybrid vector + knowledge graph retrieval). Users configure an embedding/LLM provider (e.g., OpenAI), ingest documents into per-KB directories, and query the resulting index via an MCP (FastMCP) interface for use by MCP-capable AI clients.

jetpack-compose-skills

Provides an “agent skill” (reference documentation files) to help AI agents write, review, and reason about modern Android Jetpack Compose best practices, including state management, effects, navigation, theming, accessibility, and performance.

mcp-fantastical

Provides an MCP server for the macOS Fantastical calendar app. It uses AppleScript (and optionally a native EventKit/Swift helper) to create events from natural language, list today/upcoming events, search events, open Fantastical to a date, and list available calendars.

SimpleMem

SimpleMem is a Python memory framework for LLM agents that stores, compresses (semantic lossless compression), and retrieves long-term memories using semantic/lexical/symbolic indexing. It supports cross-session/persistent memory and can be used via MCP (cloud-hosted and/or run locally with Docker) and via Python integration with OpenAI-compatible LLM/embedding backends.

anki-mcp-server

An MCP (Model Context Protocol) server that connects a client (e.g., Claude Desktop) to Anki via the AnkiConnect plugin, exposing Anki decks and note models as MCP resources and providing tools to list/create notes.

powerpoint-mcp

Provides an MCP server that generates and edits PowerPoint (.pptx) presentations via MCP tools (create presentation, add slide types like title/content, tables, charts, and picture slides). It can also generate images using a Stable Diffusion WebUI (ForgeUI/Automatic1111) and save both images and the final deck to a configured folder.

ai-testing-mcp

A self-hosted MCP (Model Context Protocol) server that provides tools to run AI test suites (unit/integration/performance/security/quality) and evaluate model outputs using various metrics. It is configured to use external model providers (e.g., OpenAI/Anthropic) via environment variables and exposes MCP tool definitions such as run_test_suite, evaluate_output, and generate_test_cases.

mcp

Provides an MCP server (TypeScript/Node via @salesforce/mcp) that lets an MCP client/LLM securely interact with Salesforce orgs using a configurable set of DX/MCP tools (e.g., orgs, metadata, data, users, DevOps Center, etc.).

mcp-handler

mcp-handler is a Vercel/Next.js (and Nuxt) adapter that lets you expose Model Context Protocol (MCP) servers over web transports such as Streamable HTTP and Server-Sent Events (SSE). It provides a createMcpHandler wrapper to register MCP tools with input schemas and handler functions, then exports Next.js route handlers for GET/POST.

mcp-koii

Provides an MCP (Model Context Protocol) server that controls a Teenage Engineering EP-133 K.O. II sampler via MIDI, exposing commands for connecting to MIDI ports, playing notes and drum patterns, and browsing the device’s sound/pad mappings.

mcp-stocks-info-server

Provides an MCP (Model Context Protocol) server for retrieving MOEX stock quotes and related market/financial news, with tools for stock search, gainers/losers, today’s news, keyword search, and news by ticker. Supports caching (Redis or in-memory) and optional storage of historical data in MongoDB, and exposes predefined MCP tools and prompt templates for LLMs.

mie

MIE (Memory Intelligence Engine) is a local/persistent memory layer for AI agents. It exposes an MCP server with tools to store, query, update, delete, export, and repair a typed knowledge graph (facts/decisions/entities/events/topics) backed by an embedded graph database (CozoDB) and optional local embeddings (e.g., via Ollama).

skillboss-skills

SkillBoss Skills is a skills/MCP-enabled integration layer for AI coding agents, providing access to 100+ AI services (chat LLMs, image/video generation, TTS, etc.) via a unified API key. It includes a CLI, an MCP server package for MCP-compatible clients (e.g., Claude Code/Cursor/Windsurf/Cline), and skill pack documentation for agent platforms, plus related deployment/workflow integrations (e.g., Cloudflare Workers, D1/KV/R2 provisioning, Stripe payments, scraping/search, email sending).

adeu

Adeu is a Python DOCX redlining engine and MCP server that helps AI agents apply “Track Changes” edits to Microsoft Word documents by calculating diffs and injecting native Word XML (w:ins/w:del) and comments without breaking existing formatting/layout.

Claude-Patent-Creator

An AI-assisted patent drafting and analysis system for Claude Code that combines (1) an MCP server exposing tools for MPEP/USC/CFR regulation search via hybrid RAG, (2) large-scale patent search via Google BigQuery (public patent datasets) plus optional USPTO API checks, (3) automated 35 USC 112(a)/(b) and formalities-style reviews, and (4) diagram generation using Graphviz.

entroly

Entroly is a context engineering/optimization tool for AI coding agents. It ingests and indexes a workspace, scores/selects and compresses codebase context to fit within token budgets, and delivers that optimized context to agents via an MCP server or a local HTTP proxy. It also provides a dashboard/metrics, explain endpoints, and optional reinforcement-learning-style weight adjustment from feedback.

HowToCook-mcp

A Model Context Protocol (MCP) server that exposes a recipe/diet assistant backed by the HowToCook dataset, offering tools to query recipes, filter by categories, fetch recipe details, recommend a weekly menu based on constraints (e.g., allergies/avoid items/people count), and generate a menu for today.

TensorRT-LLM

TensorRT-LLM is an open-source Python/C++ toolkit for building and running optimized LLM inference on NVIDIA GPUs. It provides a Python API to define models and build high-performance inference runtimes/engines, along with serving/orchestration components and performance-focused optimizations.

zero-mcp

zero-mcp is a lightweight TypeScript toolkit for implementing MCP (Model Context Protocol) servers that expose JSON-RPC tool endpoints over native HTTP. It provides a McpServer abstraction with tool registration (Zod-based schemas + JSON schema generation) and lifecycle hooks, plus CORS controls for browser-based clients.

f2c-mcp

An MCP (Model Context Protocol) server that lets an MCP-supported IDE connect to Figma and use F2C to parse Figma design nodes/links and generate pixel-perfect HTML/CSS and framework-specific code (e.g., React, CSS Modules, Tailwind). It also supports localization of remote Figma images to local assets.

mcp-mem0

Provides an MCP server template integrated with Mem0 to let AI agents save, retrieve, and semantically search long-term memories backed by Supabase/PostgreSQL (vector storage) and configurable via an LLM provider for embeddings.

nexonco-mcp

nexonco-mcp is an MCP server that exposes a tool (search_clinical_evidence) for querying and returning formatted clinical evidence from the CIViC database via flexible filters such as disease, therapy/drug, molecular profile/variant, phenotype, and evidence metadata.

ableton-mcp-extended

A Python MCP (Model Context Protocol) server plus supporting Ableton Live remote-script components that let an AI assistant control Ableton Live (session/transport, tracks, MIDI clips/notes, devices/parameters, automation, and browser loading/import). It also includes optional integrations for text-to-speech/audio generation via ElevenLabs MCP and a TCP/UDP hybrid mode for low-latency real-time parameter control.

Code-Index-MCP

Code-Index-MCP is a local-first code indexing and search MCP server for AI coding assistants. It builds a repository index (SQLite+FTS5) from local source files using tree-sitter-based parsing and supports symbol resolution and lexical search, with optional semantic search via embeddings (e.g., Voyage AI). It can watch the filesystem for updates and optionally sync/publish index baselines via GitHub artifacts. It also provides a FastAPI REST gateway and an MCP interface for assistant integration.

ContextGraph

ContextGraph is a governed shared-memory layer for multi-agent systems. It stores agent claims with provenance/freshness/trust metadata, enforces access control at retrieval time, and compiles token-budgeted “context packs” (optionally explainable) for each agent’s permissions. It provides a Python SDK, CLI/dashboard, an HTTP REST API, and an MCP server/tool integration, with optional Anthropic Claude Memory Tool adapter support and a Neo4j-backed self-hosted beta path.

databricks-mcp-server

Databricks MCP Server is a Model Context Protocol (MCP) server that exposes tools for browsing Databricks workspace objects (catalogs, schemas, tables, SQL warehouses) and for executing SQL statements against a Databricks SQL warehouse, returning results to the MCP client.

gemini-skill

Provides an MCP server that automates Gemini (web) interactions by driving a real browser via CDP/DevTools. It spawns/controls a background browser daemon, exposes MCP tools for chat, image generation, image upload/extraction/download, session navigation, and includes a watermark-removal step for downloaded images.

goai

GoAI is a Go library that provides a unified, type-safe interface for working with multiple LLM providers (OpenAI, Anthropic Claude, AWS Bedrock), generating vector embeddings, and performing similarity search using vector storage (including PostgreSQL vector storage). It also claims support for streaming and provides a documented Model Context Protocol (MCP) server for Go.

java-mcp-sql-server

Provides an MCP server (Java 21+) that connects to relational databases via JDBC and exposes tools to list schemas/tables, inspect table structure, query table data, and execute custom SQL (optionally restricted to SELECT). Supports stdio (local launch) and HTTP/SSE (remote connection) modes.

nelson

Nelson is a Claude Code skill/plugin that provides a structured, risk-tiered orchestration framework for coordinating multi-agent coding sessions. It defines “sailing orders,” forms a squadron of roles (admiral/captains/red-cell), runs tasks via checkpoints (“quarterdeck rhythm”), enforces risk-tier controls (“action stations”), and produces auditable decision logs (“captain’s log”) plus recovery procedures (“damage control”).

oracle.oci-generative-ai-mcp-server

MCP server for Oracle OCI Generative AI service, enabling AI agents to access OCI-hosted LLMs for text generation, summarization, and embedding generation. Wraps OCI Gen AI APIs including inference endpoints for models like Cohere and Meta Llama hosted on OCI.

pubmearch

Provides an MCP server (Python) that queries PubMed using NCBI advanced search, saves result files, and performs analyses such as keyword hotspot frequency, keyword trends over time, publication count over time windows, and generates comprehensive reports.

ctxvault

CtxVault provides a local-first semantic memory system for AI agents. Memory is organized into directory-backed 'vaults' with independent vector indexes and optional access restrictions. It supports a CLI for managing/indexing/querying vaults, a FastAPI-based HTTP REST API for CRUD/search/write operations, and an MCP server for direct agent access (list/query/write/docs).

doctor

Doctor is an agent-oriented web discovery/crawling and indexing system. It crawls web pages, chunks and embeds text (via OpenAI through LiteLLM), stores results in DuckDB with vector search, exposes a FastAPI HTTP API for fetch/search/map navigation, and provides access to these capabilities via an MCP server endpoint (/mcp) for LLM agents.

go_mcp_server_tinvest

A lightweight MCP server in Go that integrates with the Tinkoff Invest API, exposing tools for searching instruments, placing market buy/sell orders, retrieving portfolio state, and getting market data (last price, order book, candles, trading status). It can run over MCP stdio and also includes an SSE HTTP server mode.

mcp

Provides an MCP (Model Context Protocol) server implementation for Frappe (Werkzeug/WSGI) apps, exposing registered Python functions as MCP tools over Streamable HTTP via a Frappe REST endpoint.

Meting-Agent

Meting-Agent wraps the metowolf/Meting multi-platform music API into a unified interface and provides it as both an MCP server (via @eldment/meting-agent) and a “Skill” release (via skills/meting-agent). It exposes operations like searching tracks/albums/artists, fetching song/album/artist/playlist details, retrieving playable URLs, lyrics, and cover images for platforms such as NetEase, QQ Music, KuGou, and Kuwo.

python-utcp

python-utcp provides a modular Python implementation of the Universal Tool Calling Protocol (UTCP), centered on a core client library (UtcpClient) plus pluggable protocol “call templates” (e.g., HTTP, CLI, MCP, file/text, websocket). It supports defining a tool “manual” (discovery) and calling tools via configured call templates using typed (Pydantic) models.

aws-mcp

aws-mcp is a local Model Context Protocol (MCP) server that lets an AI assistant query and manage AWS resources (across regions) using your locally configured AWS credentials/profiles (including SSO). It’s designed to be run on your machine and connected to via Claude Desktop’s MCP server configuration.

clarifai-mcp-server-local

Provides a local (user-run) Model Context Protocol (MCP) server that bridges MCP clients to Clarifai’s API. It exposes MCP tools for uploading files, generating images from text, and running image inference by local path or URL, plus read-only MCP resources for listing/searching/reading Clarifai entities (inputs, annotations, models, model versions, datasets). It communicates with the client over JSON-RPC 2.0 via stdio and calls Clarifai using a gRPC client with a Clarifai Personal Access Token (PAT) provided via CLI flag.

marketo-mcp-server-by-cdata

Provides a local, read-only MCP server for querying Marketo data via the CData JDBC Driver, exposing database-like tables/columns and a simple tool interface (get_tables, get_columns, run_query) to MCP clients (e.g., Claude Desktop) over stdio.

cursor-talk-to-figma-mcp

Provides an MCP server (plus a companion WebSocket + Figma plugin) that lets an AI agent read Figma/FigJam documents and programmatically modify design elements (e.g., text, layout, styling, components/overrides, connections, annotations) via MCP tools.

freecad-mcp

Provides a local MCP (Model Context Protocol) server integrated with FreeCAD, allowing an AI client (e.g., Claude Desktop) to create/edit/delete FreeCAD documents and objects, execute FreeCAD Python code, and retrieve views/objects/parts library information. Includes an installation method as a FreeCAD addon and a CLI command to run the MCP server.

kospi-kosdaq-stock-server

Provides an MCP (FastMCP) server that fetches KOSPI/KOSDAQ stock data (tickers, OHLCV, market cap, fundamentals, investor-type trading volume) and KOSPI/KOSDAQ index OHLCV from KRX Data Marketplace. Uses Kakao OAuth with Playwright for authentication and maintains/refreshes a session cookie.

sugar-crm-mcp-server-by-cdata

Provides a local, read-only MCP server that exposes Sugar CRM data to AI clients (e.g., Claude Desktop) by wrapping the CData JDBC Driver for Sugar CRM and presenting a small set of MCP tools (get tables, get columns, run read-only queries).

agentset

Agentset is an open-source platform for building, evaluating, and deploying production-ready RAG and agentic applications, including ingestion, chunking, embeddings, retrieval, evaluation/benchmarks, a chat playground, and (cloud or self-hosted) hosting. It also claims a developer-friendly API with typed SDKs and an OpenAPI spec, plus multi-tenancy and an MCP server.

amazon-redshift-mcp-server-by-cdata

Provides a local MCP (Model Context Protocol) server that wraps the CData JDBC Driver for Amazon Redshift, exposing database metadata (tables/columns) and query execution via MCP tools so an LLM client can retrieve Redshift data (README describes read-only as the project’s intent).

autogen-ext-mcp

Provides an AutoGen extension that exposes Model Context Protocol (MCP) server tools to AutoGen agents by connecting to MCP servers (e.g., via stdio) and converting MCP tool schemas into AutoGen-compatible tool interfaces. Note: repository is archived and functionality is integrated into the official autogen-ext package (v0.4.6+).

skillhub

SkillHub is a self-hosted, open-source agent skill registry that lets organizations publish, version, govern, and distribute reusable “skill packages” within private namespaces. It provides a Web UI and CLI-first workflows plus a backend REST API, with RBAC and audit logging, and supports pluggable storage (filesystem, S3/MinIO).

utsunomiya-mcp-server

Provides an MCP server that exposes Utsunomiya City open data via natural-language queries and MCP tools (list datasets, get dataset schemas, query dataset contents, and analyze datasets with caching).

zed-mcp-server-markitdown

Provides an MCP server integration for Zed that exposes a `convert_to_markdown(uri)` tool to convert documents (PDF/DOCX/XLSX/PPTX), images (with OCR), audio (with transcription), web pages (URLs), structured data (CSV/JSON/XML), and ZIP archives into AI-consumable Markdown context via MarkItDown.

AgentCrew

AgentCrew is a Python multi-agent AI framework and desktop/CLI application for building teams of specialized agents that collaborate via transfer or parallel delegation. It supports multiple model providers and tool integrations, including MCP-connected external tools, and can expose agents as HTTP services via an A2A (JSON-RPC) server.

agentscope

AgentScope is a Python multi-agent framework for building, orchestrating, and running LLM agents with reusable abstractions (agents, toolkits, memory, planning/workflows) and integrations including MCP tool support and additional protocols (e.g., A2A) plus observability via OpenTelemetry.

devduck

DevDuck is a Python-based, “one-file” self-healing AI agent runtime that can hot-reload code, run many built-in tools (including shell/git/browser/messaging), and connect across multiple interfaces (CLI/TUI/WebSocket/TCP) and networks (Zenoh P2P + a unified mesh/relay). It can also expose itself as an MCP server and deploy to AWS AgentCore.

ghidra-headless-mcp

Provides a headless Ghidra server that exposes Ghidra reverse-engineering workflows to AI agents via the MCP (Model Context Protocol), with stdio (default) and TCP transports and both real (pyghidra) and fake-backend modes.

google-search-mcp-server-by-cdata

Provides a local, read-only MCP server that exposes Google Search data as relational tables via CData's JDBC Driver. The MCP server runs over stdio so an MCP-capable desktop client (e.g., Claude Desktop) can query live Google Search data using tool calls like get_tables, get_columns, and run_query (SQL SELECT).

powerpoint

Provides an MCP server (Python) that creates and edits PowerPoint (.pptx) presentations: generating deck files, adding different slide types (title, section header, title+content, tables, charts, pictures with captions), opening existing decks for editing, saving backups/final output, and optionally generating images via TogetherAI using a FLUX model.

sap-hana-mcp-server-by-cdata

Provides a local MCP (Model Context Protocol) server for SAP HANA using CData JDBC Drivers. It is intended to expose SAP HANA data as callable MCP tools (table/column discovery and SQL SELECT execution) for local clients such as Claude Desktop, over stdio.

spicebridge

spicebridge is an MCP server (and CLI) that lets an AI generate SPICE netlists and run ngspice simulations from natural-language/templated circuit descriptions. It supports AC/transient/DC analyses, measurement extraction, spec comparison, Monte Carlo/worst-case tolerance analysis, exporting (KiCad, schematic viewer), and optional cloud deployment via Cloudflare Tunnels.

amazon-athena-mcp-server-by-cdata

Provides a local, read-only MCP server that wraps a CData JDBC Driver for Amazon Athena, exposing Athena tables/columns and SELECT query execution as MCP tools for AI clients (e.g., Claude Desktop).

bing-ads-mcp-server-by-cdata

Provides a local, read-only MCP server that exposes Bing Ads data (via CData JDBC Driver for Bing Ads) as MCP tools (list tables/columns and run SELECT queries). Intended to be used with MCP-capable desktop clients (e.g., Claude Desktop) through stdio on the same machine.

mcp-weather-server

A Java (Spring Boot) MCP server that exposes weather data and real-time stock price data. It supports SSE streaming via a localhost endpoint and fetches stock prices from API Ninja using a provided API key.

OpenRLHF

OpenRLHF is an open-source RLHF framework for training and improving language models using reinforcement learning from human feedback. It provides distributed RL training (e.g., PPO, REINFORCE++, GRPO, RLOO) built around Ray orchestration and vLLM-based fast sample generation, with support for multi-turn agent-based execution and integration with HuggingFace/DeepSpeed for large-model training.

uh-joan-pubmed-mcp-server

An MCP server package that provides PubMed-related capabilities to an agent via the Model Context Protocol. It is intended to let an AI agent query and retrieve PubMed article data as part of a tool-using workflow.

Ultimate-AI-Media-Generator-Skill

Provides an open-source “skill” for AI coding/agent platforms that can generate images and videos using CyberBara-backed models (e.g., Nano Banana, Sora, Seedance, Kling/Ve o), including helper commands for credit quotation/balance checks and task waiting to retrieve final media URLs.

youtube-mcp-server

Provides an MCP server for querying YouTube data (e.g., search channels and fetch channel metadata/stats) using two transports: stdio for local use and a remote SSE-based transport exposed over HTTP.

ayunis-legal-mcp

Provides an MCP server (FastMCP) and supporting FastAPI “Store API” for importing, storing (PostgreSQL + pgvector), and semantic-searching German legal texts (scraped/parsed from gesetze-im-internet.de). Includes a CLI for importing/querying and an MCP tool set for AI assistants to search and retrieve legal sections.

Dive

An open-source desktop application that serves as an MCP host, connecting any LLM (ChatGPT, Anthropic, Ollama, OpenAI-compatible) with MCP servers through a unified chat interface. Supports stdio and SSE MCP transports, includes built-in tools (Fetch, File Manager, Bash), offers 24+ language support, and provides an installer agent for automatic MCP server configuration. Available in Electron and Tauri variants across Windows, macOS, and Linux.

GhidrAssistMCP

GhidrAssistMCP is a Ghidra extension that runs an MCP (Model Context Protocol) server, exposing a set of reverse-engineering tools, static program resources, and pre-built prompts so external AI assistants/tools can query and modify analysis state inside Ghidra (e.g., functions, strings, types, comments, renaming, structure operations).

LitServe

LitServe is a lightweight Python framework (FastAPI-based) for building and serving custom AI inference servers. Users implement a LitAPI with `setup()` and `predict()` (and potentially more advanced logic like batching/streaming/routing), then run it via `LitServer` to expose an HTTP API for inference pipelines, including agents, RAG, and multi-model workflows. It supports self-hosting and deployment via Lightning’s cloud offering.

mcp-bench

MCP-Bench is an evaluation framework that benchmarks tool-using LLM agents on complex tasks using the Model Context Protocol (MCP). It orchestrates discovery/connection to multiple MCP servers, runs benchmark tasks (single- and multi-server settings), and evaluates outputs (including LLM-as-judge).

pencilplaybook

PencilPlaybook is a Claude Code “skill” intended to guide Claude in producing UI/design outputs inside Pencil.dev by embedding perceptual design defaults (token lookup tables), structured workflows for working with .pen canvases, and presets/scaffolds for common screen archetypes. It also references a setup wizard that configures design-system presets and claims to provide a complete parameter reference for 12 Pencil MCP tools.

qurio

Qurio is a self-hosted ingestion and retrieval (RAG) engine for AI coding assistants. It crawls or ingests local documents (e.g., web pages, PDFs, Markdown), chunks content structurally, embeds it (Gemini for embeddings), stores vectors/metadata in Weaviate/PostgreSQL, and exposes retrieval to agents via an MCP server over a JSON-RPC 2.0 endpoint.

sample-agentic-ai-web

Sample Python project showing how to build an agentic web automation assistant using AWS Bedrock (Claude and Amazon Nova) with tool use, human-in-the-loop interruptions, and vision (screenshots). Includes progressive steps culminating in an MCP (Model Context Protocol) client/server refactor and conversation history/token-management enhancements.

solana-mcp-server

Solana MCP server that exposes a set of Solana JSON-RPC-like capabilities (accounts, blocks, transactions, tokens, cluster/system info, staking/governance) to an MCP-capable client (described as working through Cline) using Rust.

docusign-mcp-server-by-cdata

A local, read-only MCP server that exposes DocuSign data via CData JDBC Driver (SQL-modeled tables/columns) to LLM clients (e.g., Claude Desktop) over MCP stdio. It provides MCP tools to list tables/columns and run SQL SELECT queries through the JDBC driver.

fullstack-langgraph-nextjs-agent

A production-oriented Next.js/TypeScript template for building LangGraph.js-based AI agents with dynamic tool loading via Model Context Protocol (MCP), optional human-in-the-loop tool approval, persistent thread-based conversation memory backed by PostgreSQL (LangGraph checkpointer), and real-time streaming responses via SSE. It also includes multimodal file upload/storage using S3-compatible backends (e.g., MinIO for dev).

Gemini Flow

An archived AI orchestration platform that coordinated 66 specialized agents using A2A and MCP dual protocol support, integrating Google AI services (Veo3, Imagen4, Lyria, etc.) for enterprise-scale multi-agent workflows with Byzantine fault-tolerant consensus.

kratos-mcp

kratos-mcp is an MCP server that provides a local “memory” layer for AI coding tools. It auto-detects projects, stores memories in per-project SQLite databases (optionally global/shared), and exposes MCP tools for saving/searching/retrieving/forgetting memories plus basic project management and a local security_scan for detecting PII/secrets in text before saving.

paws-on-mcp

Provides a local Python-based MCP (Model Context Protocol) server (with SSE transport) exposing a set of MCP tools, resources, and prompt templates, plus an enhanced sampling workflow with model hints and priority parameters. Includes a CLI client for testing and interacting with the MCP server.

power-bi-xmla-mcp-server-by-cdata

Provides a local, read-only MCP server that wraps the CData JDBC Driver for Power BI XMLA, exposing Power BI XMLA data as MCP tools (get tables/columns and run_query) for LLM clients such as Claude Desktop.

sap-erp-mcp-server-by-cdata

Provides a local, stdio-based MCP server (read-only) that wraps the CData JDBC Driver for SAP ERP, exposing SAP ERP data as tools for an AI client (e.g., Claude Desktop). It supports listing tables/columns and running SQL SELECT queries (and, per README text, is read-only).

agno

Agno is a Python runtime/framework for building, running, and managing agentic software at scale. It provides an agent framework with tools and integrations (including MCP tools), a production runtime using a stateless, session-scoped FastAPI backend, and a control plane/UI (AgentOS) for testing, monitoring, and management.

Auto-claude-code-research-in-sleep

Auto-claude-code-research-in-sleep (ARIS) is a collection of Claude Code–style “skills” (Markdown-based workflows) that orchestrate an autonomous ML research pipeline: idea discovery, cross-model review loops (Claude Code as executor, an external LLM via MCP/Codex-style reviewer), experiment planning/bridging, paper writing, and post-submission rebuttal plus slide/poster generation. It also documents adaptations for other agent IDEs (Cursor, Trae, Antigravity, OpenClaw) and supports alternative model combinations via OpenAI-compatible APIs (as a reviewer).

google-analytics-mcp-server-by-cdata

Provides a local, read-only Model Context Protocol (MCP) server that exposes Google Analytics data to LLM clients. It wraps a CData JDBC Driver for Google Analytics, generates MCP tools for listing tables/columns and executing SQL SELECT queries via tools/call, and is intended to be run locally using stdio (same machine as the MCP client).

inference

Xinference (Xorbits Inference) is an inference/model-serving library that lets you run and serve language, speech, and multimodal (and vision/audio-related) models through multiple interfaces, including an OpenAI-compatible REST API, with support for local, self-hosted, and distributed deployments using heterogeneous hardware (CPU/GPU).

mcp

A monorepo of reference MCP (Model Context Protocol) server implementations for managing/interacting with Oracle products (not intended for production). It provides multiple MCP servers under src/, with setup guidance for running them via MCP-compatible clients (stdio/streamable HTTP) and for OCI-backed servers using OCI CLI credentials.

mcp-agent-langchainjs

A TypeScript/Node.js sample application that demonstrates building an AI agent using LangChain.js with Model Context Protocol (MCP) tools to browse a burger menu, place orders, and query order status. It includes a burger ordering REST-style backend, an MCP server exposing burger operations as MCP tools (serverless/HTTP), and agent UIs/APIs/CLI for interacting with the toolset.

node-runtime

This package is intended for demonstration purposes only and is not for production use. Maintained by JFrog Security for simulation purposes.

pubchempy-mcp-server

pubchempy-mcp-server is an MCP server wrapper for PubChemPy, exposing PubChem-related operations as MCP tools so an agent can query/lookup chemical information via the MCP protocol.

davinci-resolve-mcp

An MCP server that lets an AI client (e.g., Claude Desktop or 5ire) connect to DaVinci Resolve Studio and perform actions such as project/timeline/media management, opening pages, working with Fusion compositions, querying current state, and executing Python/Lua code inside Resolve/Fusion.

exa-pool-mcp

Provides an MCP server wrapper that exposes the Exa Pool API as tools for AI assistants, using a Python stdio transport (per README) configured via environment variables.

lsbot

lsbot is a Go-based local-first AI bot/agent runtime that connects to external AI providers via a relay (cloud relay for certain chat platforms) and exposes local system capabilities to MCP-compatible clients. The README emphasizes E2EE-style relay traffic using a locally stored keypair and encrypted WebSocket transport, plus local storage of configuration/history/keys.

mcp-toolkit

@nuxtjs/mcp-toolkit is a Nuxt module that helps you build Model Context Protocol (MCP) servers inside a Nuxt application. It provides file-based, zero-configuration discovery of MCP tools/resources/prompts, supports multiple MCP endpoints per app, adds TypeScript-first typing with Zod validation, and includes a built-in inspector in Nuxt DevTools for debugging.

mindbridge-mcp

mindbridge-mcp is a Model Context Protocol (MCP) server/bridge that routes tool calls to multiple LLM providers (e.g., OpenAI, Anthropic, DeepSeek, Google, OpenRouter, Ollama) and exposes MCP tools such as getSecondOpinion plus listing tools like listProviders and listReasoningModels. It also supports an OpenAI-compatible API layer according to the README.

super-agent-party

Super Agent Party is a self-hosted AI desktop companion that bundles chat/agent capabilities, task automation, bots for multiple messaging/live-streaming platforms, a browser automation feature, and an extension system. It exposes an OpenAI-compatible HTTP API (base_url http://localhost:3456/v1) and an MCP endpoint (e.g., http://127.0.0.1:3456/mcp) intended for external agent integration.

adobe-analytics-mcp-server-by-cdata

Provides a local, read-only MCP server that wraps CData’s JDBC Driver for Adobe Analytics, exposing Adobe Analytics data as MCP tools (get_tables, get_columns, run_query) for LLM clients (e.g., Claude Desktop) to query live data without writing SQL.

gemini-webapi-mcp

Provides an MCP server that bridges to Google Gemini for image generation/editing, file analysis (e.g., images/PDFs/videos), and text chat by using Gemini web access authenticated via browser cookies from Chrome (or manually provided cookie values).

mcp-agent

A TypeScript framework for building AI agents that can interact with Model Context Protocol (MCP) servers and local tool functions. It provides agent abstraction, an MCP connection manager for reusing server connections, per-agent MCP tool aggregation, LLM provider integration (example for Fireworks AI), simple in-memory message history, and example orchestration/workflows.

perplexity-mcp-server

Perplexity-focused MCP server that exposes tools to an MCP-capable agent so it can perform Perplexity-powered search/browsing and return results in the agent workflow.

salesforce-data-cloud-mcp-server-by-cdata

Provides a read-only Model Context Protocol (MCP) server that exposes Salesforce Data Cloud as relational SQL tables by wrapping CData's JDBC Driver. It runs as a local process using stdio and offers MCP tools for listing tables/columns and running SQL SELECT queries.

sap-successfactors-mcp-server-by-cdata

Provides a local, read-only MCP server wrapper around the CData JDBC Driver for SAP SuccessFactors. It exposes SuccessFactors data as SQL tables/models and lets an MCP-capable client (e.g., Claude Desktop) discover tables/columns and run read queries via MCP tools over stdio on the same machine.

ucp-mcp-server

Provides an MCP server exposing UCP (Universal Commerce Protocol) shopping flows as callable tools for AI assistants, including merchant capability discovery, checkout creation, checkout updates (discounts), fulfillment/shipping setup, and checkout completion/payment submission.

matlab-mcp-server

Provides an MCP server that integrates MATLAB with an AI assistant. It exposes MCP tools to (1) execute MATLAB code and (2) generate MATLAB code from natural language, and it exposes a resource/URI to access MATLAB documentation.

mcp-chat

mcp-chat is an open-source chat application template/demo that integrates Pipedream’s MCP server to enable AI chat-based tool calling across many third-party APIs, using the Vercel AI SDK for model/tool orchestration and optional persistence/sign-in.

mcp-kit

mcp-kit is a Go-based toolkit that provides an MCP server and MCP client implementation (using github.com/shaharia-lab/goai/mcp), plus an HTTP API server layer that exposes REST endpoints and orchestrates requests between a frontend, the MCP client, and LLM providers. It also includes monitoring/observability via Prometheus/Grafana/Loki/Promtail and provides an OpenAPI schema file (openapi.yaml) for the API server.

ollama-mcp-bridge

A TypeScript bridge that connects Ollama-hosted local LLMs to MCP (Model Context Protocol) servers via JSON-RPC. It registers MCP tools, routes tool calls produced by the LLM to the appropriate MCP server(s), and validates/returns structured results to the user.

rapidocr-mcp-server

Provides an MCP server that exposes OCR capabilities (based on RapidOCR) via two tools: OCR from base64-encoded image content and OCR from an image file path.

weather-mcp-server-java

Provides a Model Context Protocol (MCP) weather tool via a Java (Spring Boot–based) MCP server using STDIO transport. The exposed tool fetches current weather details for a specified location by calling the free wttr.in weather endpoint (no API key mentioned).

AgentChat

An LLM-based intelligent agent platform that combines multi-agent collaboration, RAG knowledge retrieval, MCP server integration, and memory management for complex conversational AI workflows.

mcp-fhir

@flexpa/mcp-fhir is an experimental MCP (Model Context Protocol) server that connects to a FHIR server using SMART on FHIR access tokens. It exposes MCP tools to search for FHIR resources and read individual FHIR resources, returning results in FHIR JSON and supporting resource access via fhir:// URIs.

visiblyai-mcp-server

Provides an MCP server that exposes VisiblyAI SEO tools to Claude Code, including local/free SEO helper tools and paid API-powered analysis tools (credits-based), plus tools that can query connected Google Search Console/GA4 data via the VisiblyAI platform.

decipher-research-agent

A full-stack AI research assistant that turns topics/URLs/documents into “research notebooks” with automated web sourcing (via Bright Data MCP), summarization, interactive Q&A over embedded content (Qdrant), FAQ generation, mindmaps, and audio overviews.

maigret

Maigret is an OSINT/OSINT-framework style Python CLI (and optional web UI / Telegram bot / Docker image) that collects public “dossiers” by username. It searches across thousands of supported sites, parses profile pages to extract available information and links, supports recursive discovery of new usernames/IDs, can detect censorship/captchas, and retries requests. It can also check Tor/I2P-related targets and domains via DNS resolving.

mcp-servers

Provides multiple Model Context Protocol (MCP) server implementations (Python, Go, Rust) that expose MCP functionality over HTTP/SSE for use with MCP-capable clients (e.g., VS Code). Includes a Docker Compose setup to run the servers.

mcp-server-weread

Provides an MCP server for WeRead (微信读书) to expose a user’s bookshelf, search results, and book notes/highlights (optionally organized by chapter), plus popular reviews, to MCP-capable LLM clients (e.g., Claude Desktop).

weather-mcp-server

Weather API MCP server that exposes an MCP tool (e.g., current_weather) to fetch current weather data for a specified city, using WeatherAPI via an API key. Intended for use with AI assistants through MCP over stdio (local) or SSE (remote).

agent-architecture-review-sample

An open-source sample “Architecture Review Agent” that accepts architectural descriptions (YAML/Markdown/plaintext/files), parses and/or uses LLM inference to produce a structured risk analysis and recommendations, and generates interactive Excalidraw diagrams (with PNG export). It can run as a local CLI, a FastAPI-based web app (custom REST endpoints), or as a Microsoft Foundry hosted agent exposing an OpenAI Responses-compatible `/responses` endpoint.

CutterMCP-plus

Provides an MCP-enabled interface to Cutter (reverse engineering tool). It exposes Cutter operations (listing functions/globals/strings/segments, decompiling/disassembling, xrefs, renaming, comments/types, and reading bytes/addresses) via a local HTTP plugin inside Cutter and an MCP wrapper that can run in STDIO or streamable HTTP mode.

go_mcp_server_youtube_search

Provides an MCP server (Model Context Protocol) with tools to search YouTube videos, fetch video information by ID, and retrieve English or Russian subtitles. Can run over SSE (default) or stdio on the specified host/port.

ibm-informix-mcp-server-by-cdata

Provides a local, read-only Model Context Protocol (MCP) server for exposing IBM Informix (via CData JDBC Driver for IBM Informix) as MCP tools so an AI client (e.g., Claude Desktop) can query live data without writing SQL.

lyraios

LYRAIOS (llm-os) is a Python-based AI “operating system” that provides a Streamlit UI and FastAPI backend, integrating with the Model Context Protocol (MCP) to connect AI agents to external tools/services. It also includes built-in assistants/tools such as web search, financial analysis, file management, research via Exa, and (partially) Python code execution. It supports authentication via API keys and offers rate limiting/quotas as part of a security & access control layer.

mem-agent-mcp

mem-agent-mcp is a Python MCP (Model Context Protocol) server that connects an “obsidian-like” local Markdown memory store (user.md + entities/*.md) to LLM clients (e.g., Claude Desktop, Lm Studio, Claude Code) for memory retrieval and memory-related tool operations. It also documents memory import/connector workflows (chatgpt, notion, nuclino, github, google-docs) and ways to run the model backend locally (MLX on macOS or vLLM/OpenAI-compatible via LiteLLM proxy).

mcp-1c

MCP server (Go binary) that integrates AI assistants with 1C:Enterprise by exposing MCP tools to inspect 1C configuration/metadata and perform limited query and code-related operations over a local 1C HTTP service (and an installed 1C extension).

openbanking-mcp-server

Provides a Java (Spring Boot) Model Context Protocol (MCP) server that exposes UK Open Banking functionality (AISP account/balance/transactions and PISP payment initiation) to Claude Desktop via an MCP JSON-RPC (tools/list, tools/call) interface over stdio/bridge, with the server calling underlying UK Open Banking APIs using OAuth credentials.

unreal-mcp

Provides an MCP server integration that lets AI assistants control Unreal Engine (UE5.6+) through natural-language tool calls, translating them into Unreal Editor operations via an Unreal plugin and an embedded Python interpreter (spawn/edit actors, assets, materials, Blueprint graphs, behavior trees, and some editor/game settings).

context-engineering

A training/repository (Python) showing how to build semantic long-term memory for AI assistants using Model Context Protocol (MCP) with FastAPI/FastMCP and a hybrid RAG architecture (vector + graph + scratchpad), including example labs (e.g., a hello MCP lab) and a flagship teaching app (WARNERCO Schematica).

HelixDB-MCP-Server

HelixDB-backed MCP server for storing, querying, and updating business and customer “memory” data, including keyword (BM25) and semantic search plus relationship/interaction tracking (product/service/customer and navigation/directions).

linkedin-ads-mcp-server-by-cdata

Provides a local, read-only MCP server that exposes LinkedIn Ads data through a JDBC driver (CData) using MCP tools such as listing tables/columns and running SELECT queries. Designed to be used with local MCP-capable clients (e.g., Claude Desktop) via stdio.

toolathlon_gym

Toolathlon-GYM is a self-contained, locally runnable evaluation/training environment for LLM agents’ real-world tool use. It provides 503 automated multi-step tasks backed by a local PostgreSQL database and orchestrated via 25 MCP servers, running each task inside an ephemeral Docker container with automated preprocessing and evaluation scripts.

claude-design-auditor-skill

Design Auditor is a Claude skill that audits UI/design inputs against 18 categories (including accessibility/WCAG and ethics/dark patterns). It can analyze Figma files via Figma MCP, as well as code (HTML/CSS/React/Vue), screenshots, and written descriptions, producing scored reports, prioritized issues, and developer handoff/export artifacts (e.g., Markdown, before/after diffs). It supports English and Korean.

OpenSCAD-MCP-Server

An MCP server (Python) that turns text prompts (and optionally images) into multi-view generated images, lets users approve/deny those images, reconstructs a 3D model using CUDA Multi-View Stereo (locally or via a remote GPU server on a LAN), and generates/refines/export parametric OpenSCAD-based outputs. Includes optional printer discovery/printing and a local web UI for the workflow.

spring-ai-mcp-wallet-server

A Spring Boot 3 wallet management backend (CRUD wallets plus income/expense operations) that exposes service methods as AI-accessible tools via Spring AI’s Model Context Protocol (MCP) server integration, backed by an H2 in-memory database for testing.

estonia-ai-kit

estonia-ai-kit is an open-source monorepo that provides integration layers (MCP servers, CLI tools, and Claude Code plugin skills) to connect AI applications to Estonian digital infrastructure and services (e.g., business register/open data) and includes authenticated workflows via Smart-ID/ID-card for some services such as EMTA and LHV.

golemcore-bot

GolemCore Bot is a Java/Spring Boot framework and runnable agent that supports skill-based behaviors (Markdown SKILL.md with YAML frontmatter), MCP-based tool server integrations (stdio), tiered multi-LLM routing, optional memory and RAG, and built-in sandboxed tools (with confirmation for destructive actions). It can run as a CLI/Telgram bot and provides a web dashboard and HTTP triggers (webhooks).

openecon-data

OpenEcon Data is an AI-assisted economic data aggregator that routes natural-language requests to multiple official data providers (e.g., FRED, World Bank, IMF, Eurostat, BIS, Comtrade, plus crypto/currency sources). It provides charts and exports, and exposes access to agents via an MCP server endpoint over SSE. It also includes a web UI (data.openecon.ai/chat).

sports-data-mcp-server

Provides an MCP (Model Context Protocol) server that exposes tools for retrieving sports data such as team search, league tables, fixtures, event details, and player profiles across multiple sports (notably football/soccer and US sports like NBA/NFL/NHL/MLB). The README indicates it is free and does not require an API key, implying it uses an upstream free tier (e.g., TheSportsDB) for data access.

GPT Researcher

Autonomous research agent that plans research questions, scrapes and validates multiple web and local sources, then synthesizes findings into detailed cited reports exceeding 2000 words with 20+ sources.

mcp-annotated-java-sdk

A lightweight, annotation-driven Java SDK/framework for building MCP (Model Context Protocol) servers. It lets you define MCP resources, tools, and prompts via Java annotations, and run an MCP server in modes like STDIO, STREAMABLE (recommended), and SSE (deprecated) using a YAML configuration.

paddleocr-mcp-server

Provides an MCP (Model Context Protocol) server wrapper around PaddleOCR functionality, enabling an agent to submit images for OCR and receive extracted text/results via MCP tools.

biomed-agent

A general-purpose biomedical knowledge assistant that connects to multiple local MCP biomedical data sources (OpenTargets, Monarch, MyGene, MyChem, MyDisease), routes questions to the appropriate tools, and synthesizes answers with metadata such as confidence, citations, and limitations. Provides both a CLI and a Streamlit UI.

cdata-jdbc-mcp-server

Provides a generic MCP (Model Context Protocol) server that uses CData JDBC drivers to expose external data sources as SQL-like tables/columns and lets MCP clients run queries (and, despite the repo name/readme emphasis, it claims CRUD tools are available via MCP tools). Communication with the MCP client is via stdio on the same machine.

pgvector-azure-openai-mcp-server

MCP server that integrates pgvector with Azure OpenAI for embedding generation and vector search workflows. It exposes vector/embedding-related capabilities to MCP-capable agents so they can index, query, and retrieve similar records using pgvector-backed storage.

claude-blog

A Claude Code skill ecosystem (Python) that provides many blog-focused commands to generate, optimize, audit, and manage content at scale. It includes SEO/quality scoring, citation/fact-checking support, editorial planning (briefs/calendars/strategy), media helpers (SVG charts and Gemini-based images/audio), and optional integrations such as Google APIs and CMS taxonomy management.

mcp-think-tool

Provides an MCP (Model Context Protocol) server that implements Anthropic's "think" tool, giving the model a structured thinking space, optional thought-history clearing, and basic metadata/statistics about thinking.

mayros

Mayros is an open-source AI agent framework (TypeScript/Node) that runs locally on a user’s devices. It provides a coding/agent CLI (TUI) and a local Gateway control plane that can connect to many messaging channels, while using a knowledge graph/semantic memory (AIngle Cortex) and offering MCP server & client support for tool integration. It also includes multi-agent orchestration features and extensibility via plugins and markdown-defined agents/commands.

selene

Selene is a desktop app that runs AI agents locally (optionally with cloud) and can connect agents to messaging channels like WhatsApp, Telegram, Slack, and Discord. It supports voice (STT/TTS), images/video generation, retrieval/memory, scheduling, and extensibility via plugins and MCP tools; it also provides a developer/internal API reference and Electron-based build system.

yinming-maxcompute-mcp-server

Provides an MCP server for accessing/querying Yinming MaxCompute (Alibaba MaxCompute/ODPS) resources from an AI agent via MCP tools. Enables an agent to connect to MaxCompute, run/query operations, and retrieve results through standardized MCP interactions.

BuildMCPServer

A Python walkthrough/project that demonstrates how to build and run an MCP server (via the mcp[cli] tooling) to serve an ML model (described as a trained Random Forest) and integrate that capability into an agent workflow (Bee Framework for ReAct interactivity).

mcp-llm-bridge

Provides a bridge between MCP (Model Context Protocol) servers and OpenAI-compatible LLM APIs by translating MCP tool specifications into OpenAI function-calling schemas and mapping tool invocations back to MCP tool executions. Primarily targets OpenAI API usage, with support for other OpenAI-compatible endpoints (e.g., local servers).

prompt-library-mcp-server

Provides an MCP server (via a Python package) exposing tools to search, retrieve, share, and rate prompts from a community prompt library, with several pre-loaded prompt templates.

strategic-partner

strategic-partner is a Claude Code “advisory skill” that separates planning/advising from implementation execution. It asks clarifying questions, challenges premises, proposes alternative solution paths, then generates scoped, self-contained prompts for fresh executor sessions. It maintains persistent decision context via Claude/Serena/memory handoffs while keeping execution context disposable; it also supports optional cross-model review via Codex CLI for high-stakes changes.

dbt-llm-agent

Self-hosted web app/agent for answering data questions about a dbt project using a knowledge base built from dbt models and documentation. It includes a Next.js dashboard, a Django/DRF backend, background workers, and an optional self-hosted MCP server with OAuth2 authentication for LLM clients to query dbt model/project information.

hydra

Hydra is a configuration management framework (commonly for ML/AI and research codebases) that composes configurations, supports hierarchical config structures, and makes it easy to run experiments with parameter sweeps via command-line overrides.

mcp-server-aws-bedrock-kb-retrieval

An MCP server package that enables AI agents to retrieve relevant knowledge from AWS Bedrock Knowledge Bases (KB retrieval) and return it as context for downstream model responses.

bitcoin-mcp

bitcoin-mcp is an MCP (Model Context Protocol) server that lets AI agents interact with the Bitcoin and Lightning Network ecosystems—e.g., generating keys, validating addresses, decoding raw Bitcoin transactions, querying blockchain data, decoding BOLT11 invoices, and paying Lightning invoices via LNBits.

clawfu-skills

clawfu-skills is an MIT-licensed collection of structured “marketing skills” (159 described in the README) meant to be used by AI agents, primarily via an MCP server entrypoint (npx @clawfu/mcp-skills). Each skill is stored as a SKILL.md file with YAML frontmatter, and includes guidance such as when to use, expected AI vs human actions (“What Claude Does vs What You Decide”), and “Skill Boundaries”/limitations.

Core-Data-Agent-Skill

Provides an “Agent Skills open format” skill containing Core Data best-practice guidance: decision trees and reference documents covering persistence setup, concurrency/thread safety, fetch/performance, schema migration, and CloudKit integration.

go-utcp

go-utcp is a Go implementation of the Universal Tool Calling Protocol (UTCP) that lets clients discover and call tools through multiple transport types (e.g., HTTP, WebSocket, gRPC, GraphQL, TCP/UDP, CLI, SSE/streaming HTTP) and provides utilities like environment-variable substitution (.env) and an OpenAPI-to-manual converter.

mcp-reasoner

mcp-reasoner is an MCP server implementation for Claude Desktop that provides configurable reasoning strategies—Beam Search and Monte Carlo Tree Search (MCTS)—and reports/evaluates the quality of different reasoning paths. It also includes experimental “alpha” MCTS variants with additional (incomplete/subject-to-change) simulation layers.

-mcp-to-skill-converter

Converts an MCP server configuration into an Anthropic Claude Skill package that uses progressive disclosure: Claude loads only minimal metadata at startup, loads full tool instructions when the skill is invoked, and executes MCP tool calls externally via a generated executor.

semantic-model-mcp-server

semantic-model-mcp-server is a Python MCP server that connects to Microsoft Fabric and Power BI semantic models to browse workspaces/datasets, retrieve and validate TMSL, execute DAX queries, and create/update models via TMSL. It also includes a Best Practice Analyzer (BPA) that evaluates TMSL against a set of industry/Microsoft-recommended rules, plus tooling for detecting and using local Power BI Desktop instances for development/testing.

mcp-excel-server

Provides an MCP server (via Spring AI MCP framework) that allows an LLM to read from and write to local Excel files (.xlsx/.xls). It runs as a stdio-based MCP server (Java command) and exchanges Excel content using the MCP protocol, returning JSON for read operations and writing JSON-provided data back into Excel.

mcp-wolframalpha

Provides an MCP (Model Context Protocol) server and Python client integration for querying Wolfram Alpha. It also includes example clients (e.g., LangChain/Gemini) and a Gradio UI to submit questions and view results.

Memoh

Memoh is a self-hosted, always-on AI agent platform that runs multiple independent bot instances in containers with persistent long-term memory. It provides a web UI and integrates with multiple messaging channels (e.g., Telegram/Discord/Feishu/Matrix/WeChat/Email), supports tool use including MCP, and includes capabilities like browser automation and scheduled tasks.

pubmedmcp

pubmedmcp is a Python MCP server that provides tools for searching and fetching biomedical articles from PubMed, delegating the actual PubMed operations to the pubmedclient library.

toronto-open-data-mcp-server

An MCP server that exposes tools for working with Toronto open data sources to an AI agent (i.e., retrieve and query datasets/metadata and return results in agent-friendly form).

CodeGraphContext

CodeGraphContext provides a Python CLI and an MCP server that index local source code into a graph database (e.g., KùzuDB default, FalkorDB, or Neo4j) and enables querying relationships like call chains, callers/callees, class hierarchies, and other code structure details for AI assistants and developers.

edict

Edict is an OpenClaw-based multi-agent orchestration system that routes tasks through a structured approval/dispatch workflow (modeled as “three provinces and six ministries”) and provides a real-time dashboard/kanban with sessions, memorials (archive), model configuration, skills management (including remote skills), and controls to pause/cancel/resume tasks.

jcrawl4ai-mcp-server

jcrawl4ai-mcp-server is a Spring Boot-based MCP server (stdio transport) that exposes MCP tools to call a Crawl4ai API: it can start a crawl for a set of URLs (returning a task ID / JSON result) and fetch crawl results by taskId.

magentic-ui

Magentic-UI is a human-centered, research/prototype web agent UI that automates web tasks with a browser-based workflow. It exposes step-by-step plans, uses action guards requiring explicit user approval for sensitive operations, supports file upload, and can integrate additional capabilities via MCP servers. It is built with AutoGen and typically runs via Docker; models are configured through environment variables or a YAML config (OpenAI/Azure/Ollama/vLLM).

mcp-server

Provides an MCP server (TypeScript) intended to integrate with “InterviewReady” by exposing MCP tools/actions to (1) fetch relevant content (blogs/resources/course materials) and (2) manage user artifacts such as a notepad (notes) and scheduling Google reminders (create/get reminders).

pinterest-mcp-server-by-cdata

Provides a read-only Model Context Protocol (MCP) server that exposes Pinterest data to MCP-capable clients (e.g., Claude Desktop) via CData JDBC Driver connection using a local stdio-based process. The MCP server offers tools to list tables, list columns, and run SQL SELECT queries over the mapped JDBC schema.

takanarishimbo-datetime-mcp-server

Provides an MCP (Model Context Protocol) server implemented in Python that exposes tools for retrieving the current date and time in various formats/timezones.

chucknorris

An MCP server (installable via npx) that provides specialized “enhancement prompts” to LLMs using a dynamic schema approach, inspired by elder-plinius’ L1B3RT4S. It describes a multi-phase tool-description/scheme change intended to improve prompt effectiveness.

claude-marketing

Open-source Python “Claude Code skills” and “skill packs” that provide marketing-specific analysis frameworks, reference data, and worked examples for areas like paid media, SEO/AI search, content, CRO, analytics, e-commerce, and reporting. Intended to be copied/installed into Claude Code’s local skills directory and used by Claude Code to perform marketing audits/optimizations via natural-language workflows.

Clawith

Clawith (OpenClaw for Teams) is an open-source multi-agent collaboration platform. It provides persistent agent identities, long-term memory and per-agent workspaces, plus an autonomous trigger system (cron/once/interval/poll/on_message/webhook) to coordinate agents. The platform is positioned as multi-tenant with RBAC, quotas, approval workflows, and audit logging, and it can integrate with chat/communication channels (e.g., Slack/Discord/Feishu/Lark) and with external tool ecosystems via an MCP client.

gsd-task-manager

Offline-first task manager based on the Eisenhower Matrix (urgent/important quadrants), storing tasks locally in the browser (IndexedDB) with optional self-hosted cloud sync via PocketBase. Includes features like dependencies, recurring tasks, tags/subtasks, analytics dashboards, PWA offline support, and an npm MCP server (gsd-mcp-server) for AI assistants to read/write tasks via natural language.

lex

Lex is an (experimental) UK legal data API for AI agents and researchers, providing access to large collections of UK legislation and related materials with hybrid semantic search, and integration via Model Context Protocol (MCP) alongside an HTTP API (FastAPI) with interactive docs.

library-mcp

Provides an MCP server (Python) to query local Markdown knowledge bases. It indexes folders of .md files with front-matter metadata (e.g., title/tags/url) and exposes MCP tools to retrieve content by tag/text/slug/date range, manage tags, and rebuild the index.

mcp-nullbr-server

An MCP-compatible Java server that exposes “NullBR API” media search, metadata lookup (movies/TV/person/collections), and resource retrieval (various resource types), plus an operation to add 115 download/share links into a CMS. It serves tools over an SSE endpoint for MCP clients.

exact-online-mcp-server-by-cdata

Provides a locally hosted, read-only MCP server that exposes Exact Online data (via CData’s JDBC Driver for Exact Online) as MCP tools for listing tables/columns and executing SQL SELECT queries.

image-gen-server

Provides an MCP server (via fastmcp) that takes text prompts (intended for Cursor IDE integration) and calls an upstream image generation service (即梦AI) to generate images. It supports downloading/saving generated images to a specified folder (including configurable width/height and sampling strength) and generates multiple images per request.

last30days-skill

A Python-based “AI agent skill” that researches a topic from multiple public web sources (e.g., Reddit, X, Bluesky, YouTube, TikTok, Instagram, Hacker News, Polymarket, and the general web) over the last ~30 days, then synthesizes grounded summaries and/or tool-specific prompt guidance with citations. It is distributed as a Claude Code plugin/skill and also appears to support other clients (e.g., Gemini CLI extensions, OpenAI Codex CLI, and an “open variant” for watchlists/briefings with local SQLite storage).

resonant

Resonant is an open-source, self-hosted “relational AI companion” framework that runs a local Node.js server and orchestrates interactions with the Claude Code Agent SDK. It provides persistent identity/session continuity (via Claude Code’s memory system), an orchestrator for autonomous routines/triggers, and multiple user channels (web UI, Discord, Telegram, voice with transcription/TTS).

sap-businessobjects-bi-mcp-server-by-cdata

Provides a local, read-only MCP server that exposes SAP BusinessObjects BI data to LLM clients via MCP tools. It wraps a CData JDBC Driver connection and offers MCP tools to list tables/columns and run SELECT queries through JSON-RPC.

thingworx-mcp-server

Provides a Spring Boot MCP server that exposes PTC ThingWorx entities (Things, Properties, Services, and Collections) as AI-friendly tools/endpoints. It uses ThingWorx REST API access with AppKey authentication and includes Redis-backed caching with runtime toggles, configurable via environment variables, and Docker support.

EasyR1

EasyR1 is an open-source RL training framework (a fork of veRL) for efficient, scalable reinforcement learning (e.g., GRPO/DAPO/Reinforce++/ReMax/RLOO/GSPO/CISPO) on text and vision-language (multi-modality) models, leveraging vLLM (SPMD mode), FlashAttention, and Ray for multi-node scaling. It provides training scripts, dataset formatting guidance, and checkpoint utilities for model merging/export.

HXAudioPlayer

HXAudioPlayer is an Android Java library that wraps/augments MediaPlayer and SoundPool for music and sound-effect playback. It provides a fluent API (HXMusic, HXSound) for loading from resources or URLs/paths, controlling playback (play/pause/resume/stop), and managing sound engines on different Android versions, including notes for gapless playback and SoundPool memory workarounds.

mcp-foundry

mcp-foundry is an MCP (Model Context Protocol) server (Python/stdio) intended to provide a unified set of tools for Azure AI Foundry, covering model discovery/details, deployment-related operations, knowledge/index management for Azure AI Search, evaluation utilities for text/agents, and fine-tuning/job status and related management. The README indicates this repo is a deprecated/older experimental implementation and that a newer Foundry MCP Server exists as a cloud-hosted preview.

pdf-mcp-server

An MCP server intended to help agents work with PDF documents (e.g., converting/extracting/processing PDFs) via Model Context Protocol tools.

scholar-mcp

MCP (Model Context Protocol) server package intended to provide “scholar”/academic research capabilities to an MCP-capable agent. Provides a programmatic interface for research-oriented tools (exact endpoints/tools not provided in the prompt content).

wordnet-mcp-server

Provides a local Model Context Protocol (MCP) server exposing WordNet-based lexical lookup functions such as synonyms, antonyms, hypernyms/hyponyms, and word definitions/examples.

xiaohongshu-images-skill

A Claude Code skill that transforms markdown, HTML, or text content into beautifully styled HTML pages with AI-generated cover images, then captures them as sequential screenshots at 3:4 ratio for Xiaohongshu posting.

youtu-agent

Youtu-Agent is an open-source Python framework for building, running, and evaluating autonomous LLM agents. It provides an agent architecture built on openai-agents (async execution, streaming/tracing/agent loop capabilities), supports hybrid approaches including tool automation, agent practice/experience-based learning, and distributed end-to-end RL training pipelines, and includes example workflows for tasks like data analysis, research, RAG, and file/PPT generation.

mcp-server

Provides a Model Context Protocol (MCP) server implemented in Rust (Axum, Shuttle) with an OAuth 2.1/Auth0-based authentication flow. It exposes MCP JSON-RPC 2.0 endpoints (public initialize/handshake, protected tools/resources/prompts) and includes built-in tools/resources/prompts plus a registry-based architecture for extending capabilities.

mkinf

mkinf is a Python SDK/utility for integrating MCP-style “hub” agents/tools into applications via a unified interface (e.g., pulling tools from mkinf hub and wiring them into LangChain chains/graphs). It requires a hub account and an API key for accessing hub functionality.

pdbe-mcp-server

Provides an MCP (Model Context Protocol) server for working with PDBe (Protein Data Bank in Europe) related resources, exposing PDBe functionality to MCP-capable agents/tools.

questions-mcp-server

Provides an MCP server exposing “questions” functionality to MCP-compatible AI agents (e.g., for retrieving, answering, or searching question-like content).

ragflow-mcp-server-continue

ragflow-mcp-server-continue is an MCP server integration intended to let an AI agent interact with RagFlow (RAG) capabilities so the agent can use RagFlow-backed retrieval/workflows from within an MCP-compatible client.

apache-hadoop-hive-mcp-server-by-cdata

Provides a local, read-only Model Context Protocol (MCP) server that exposes Apache Hadoop Hive data via CData JDBC Driver as MCP tools (get tables, get columns, run SELECT queries), so local LLM clients (e.g., Claude Desktop) can query live Hive data without writing SQL.

evals

OpenAI Evals is an open-source framework for evaluating LLMs and LLM systems. It provides an existing registry of benchmark/evaluation definitions (often data-driven), tooling to run local evaluations, and guidance for creating custom evals (including model-graded evals via YAML/templates).

llm-workflow-engine

LLM Workflow Engine (LWE) is a Python-based CLI and workflow manager for building and running LLM interactions (chat/tool use) from the shell, with a plugin architecture and support for multiple LLM providers (including OpenAI via the ChatGPT API).

mcu-mcp-server

An MCP (Model Context Protocol) server implemented with Express.js that exposes a tool to generate a color scheme from a provided seed color using Google’s Material Color Utilities library.

semantic-router

Semantic Router (vLLM Semantic Router) provides a system-level routing layer for mixture-of-models by classifying or scoring incoming requests/contexts and dispatching them to appropriate models or pipelines.

jebmcp

jebmcp provides an MCP server/plugin that integrates the JEB Pro reverse-engineering environment with MCP-capable clients (e.g., Cline/Cursor/RooCode). It starts a local HTTP endpoint (127.0.0.1:16161) and exposes MCP methods for querying/manipulating decompiled/exported artifacts in JEB, including class/method/field inspection and renaming.

mcp-server

Provides an MCP server (implemented in Java) that exposes two tools: (1) real-time weather retrieval via the QWeather API, and (2) Google-search-results querying via the Serper API. Includes an example of using LangChain4J with an MCP client over stdio.

mcp-snippets-server

Provides an MCP server that performs semantic search over local Markdown code-snippet files. On first run it parses `.md` snippets, generates embeddings using an OpenAI-compatible embeddings endpoint, persists a local JSON vector store, and exposes a single MCP tool `search_snippet(topic)` for topic-based retrieval.

soccer-mcp-server

An MCP server package for soccer-related data/operations, exposed to AI agents via the Model Context Protocol so agents can call soccer tools/functions.

claude-youtube

claude-youtube is a Claude Code skill that provides YouTube creator-focused command workflows (channel audits, video SEO, scripts, hooks, thumbnails briefs, strategy, calendars, Shorts packages, analytics interpretation, competitor analysis, upload metadata, and ideation). It can operate with manual input, and optionally fetch live channel data via YouTube Data API (API key and OAuth2 for private analytics) and keyword/trend data via optional MCP integrations (e.g., DataForSEO, NanoBanana).

siliconflow-mcp-server

siliconflow-mcp-server is an MCP (Model Context Protocol) server that exposes SiliconFlow/LLM capabilities to MCP-compatible agents/tools, turning the provider’s API into callable MCP tools.

spring-boot-bitcoin-mcp-server-2025

Provides an MCP server (Spring Boot-based) that retrieves Bitcoin price data from CoinGecko’s API, intended for use with Claude Desktop via an MCP server configuration that launches a packaged JAR.

ultimate-seo-geo

Provides a Claude Code “skill” (and bundled Python scripts) that performs SEO audits and GEO (AI search optimization) for a given site/URL. It fetches and analyzes pages (technical SEO, on-page, schema, links, local/international SEO, etc.), generates a scored audit plus a prioritized plan, and can output deployable fixes such as JSON-LD and meta/redirect/robots changes. It also includes GEO-specific checks like AI crawler allow/block status and llms.txt/RSL-related templates.

agent-studio-starter

Provides a starter template for building an AI agent web app: a FastAPI backend using LangGraph Deep Agents (with tools and streaming) paired with a Next.js frontend using CopilotKit generative UI that renders tool-call events in real time. Includes Kubernetes/Skaffold deployment scaffolding.

jarvis

Jarvis is a locally-run, voice-first AI assistant for a user’s computer. It listens for a wake word (“Jarvis”), performs speech recognition (Whisper), runs an on-device intent judge and a selectable LLM via Ollama, supports local tools (e.g., screenshot/OCR, web search, weather, file access, nutrition/location features), and can connect to external capabilities via MCP servers (e.g., GitHub, Home Assistant, Google Workspace, Slack/Discord, databases). It claims 100% local processing and automatic redaction, with conversation/memory stored locally.

tcinvest-mcp-server

An MCP server package intended to expose capabilities related to “tcinvest” to AI agents via the Model Context Protocol. (Specific tools, endpoints, and behavior were not provided in the prompt, so evaluation is based on name/assumed MCP nature rather than concrete README/manifest details.)

weatherapi-mcp-server

Provides an MCP (Model Context Protocol) server that exposes WeatherAPI functionality to AI agents, enabling tools/actions to fetch weather data.

khoj

Khoj is a self-hostable “AI second brain” that provides chat and research-style Q&A over local and web/document sources using semantic search and LLMs. It supports multiple frontends (web, desktop/editor integrations) and can run agents and automations.

MassGen

MassGen is a Python-based multi-agent “scaling”/orchestration framework that runs in a terminal. It coordinates multiple LLM-backed agents to collaboratively solve tasks via parallel work, iterative refinement, convergence/consensus (voting), and real-time visualization (TUI/Web UI). It also supports integration with models/tools and mentions MCP usage for model context.

MCPin10

MCPin10 is a tutorial-style Python project intended to help developers build and run an MCP server (example: Yahoo Finance) and an accompanying agent flow (optionally via Langflow). It relies on mcp[cli] and yfinance, and expects local services like Ollama to be running.

mcp-server-bilibili-js

MCP server (Node/JS) intended to expose Bilibili-related capabilities to AI agents via the Model Context Protocol, enabling the agent to call tools for retrieving or interacting with content/metadata from Bilibili.

mcp-server-maimemo

An MCP (Model Context Protocol) server that connects a client to the Maimemo (墨墨背单词) Open API, exposing MCP tools to query and manage vocabulary-related content such as interpretations, notes, notepads, and phrases, backed by an API token (MAIMEMO_TOKEN).

MetaClaw

MetaClaw is a local proxy/agent runtime that sits in front of a user's personal agent (e.g., OpenClaw/CoPaw/etc.) and an OpenAI-compatible LLM API. It injects “skills” into prompts, can summarize sessions into new skills, and (optionally) runs asynchronous RL-style training (e.g., GRPO) on accumulated interaction data. It also includes a scheduler mode (madmax) to defer weight updates to idle/sleep/meeting windows and provides an Anthropic-compatible /v1/messages endpoint for Anthropic-native clients. A CLI (metaclaw) manages setup, config.yaml, starting/stopping, and daemon logging.

PowerMCP

PowerMCP is an open-source collection of MCP servers that let LLM host applications connect to power-system software (e.g., PowerWorld, OpenDSS, and pandapower) to enable simulation/analysis/control workflows in the energy domain.

running-marketing-campaigns-agent-skill

A Python “agent skill” that helps an AI coding agent plan, generate, and operationalize digital marketing campaigns. It includes utilities for UTM parameter generation/validation/auditing and brand-voice/compliance checking, plus reference materials for content strategy, email/social/SEO/GEO, and analytics/measurement frameworks.

transcription-mcp-server

An MCP server package intended to expose transcription functionality to agent runtimes via the Model Context Protocol, allowing agents to submit audio (or references) for speech-to-text and receive transcription results.

turn-based-game-mcp

A learning/demonstration monorepo containing a Next.js (TypeScript) web app for turn-based games (Tic-Tac-Toe and Rock Paper Scissors) plus an MCP server that exposes tools to create games and have an AI opponent make moves/choices at multiple difficulty levels. Includes shared game logic/types and an MCP stdio setup for MCP-compatible clients.

akilat-spec-leave-manager-mcp

Track and manage employee time off with quick balance lookups and streamlined applications. Find t…

bergeramit-bergeramit-hw3-tech

Create friendly greetings and add two numbers instantly. Speed up simple tasks and streamline ligh…

BigVik193-reddit-ads-mcp-api

MCP server for Reddit ads management and subreddit analytics

cesium-ai-integrations

Cesium AI Integrations is a TypeScript repository of reference integration patterns and examples that connect the CesiumJS geospatial/3D visualization ecosystem with AI systems such as Model Context Protocol (MCP) servers/applications and agent workflows (including geospatially grounded retrieval and tool/skill patterns).

dotemacs/domain-lookup-mcp

MCP server to look up domain names via rdap(1) and then whois(1).

mcp-java8-sdk

Modified most code and downgraded dependencies from the official v0.8.1 version, to support old Java 8 and Spring Boot 2.x and Solon 3.x

mcp-server-memory

An MCP server that provides memory functionality to an agent (i.e., storing and retrieving contextual information during conversations/agent runs) via the Model Context Protocol interface.

mcp-springboot-server

Provides a Spring Boot server implementation of a Model Context Protocol (MCP) server that exposes a simple weather-information service as MCP tools. It also mentions REST endpoints and SSE support and includes a small SSE client test example.

MetehanGZL-pokemcp

Pokémon information MCP server

orchestraprime

OrchestraPrime MCP Server — Regulatory intelligence and sanctions screening for Claude

saikiyusuke/registep-mcp

Registep MCP Server for ChatGPT App Store - POS Sales Analytics

dbc-mcp-server

DBC-MCP-Server is a Spring Boot service that exposes a Model Context Protocol (MCP) interface for database connection management and AI-assisted database metadata querying. It supports multiple SQL databases (e.g., MySQL, PostgreSQL, SQL Server, SQLite) via dynamic datasource switching and provides MCP “tool functions” for schema/introspection (tables, columns, foreign keys, indexes, engine) plus SQL execution and row count/statistics.

pdf-mcp-server

Provides an MCP server that reads local PDF files from a directory specified at startup, exposing tools (e.g., list/search PDFs and read PDF contents) to an MCP-capable client.

quick-data-mcp

quick-data-mcp is an MCP server (Python) intended to let an AI agent perform agentic analytics on user-provided .json and .csv files via MCP Tools/Resources/Prompts, configured through an .mcp.json file pointing at a local directory.

chatbot_Shopify

A Shopify-integrated, AI-powered commerce chatbot that provides customer support and product discovery using hybrid retrieval (FAISS + Elasticsearch) and can perform agentic shopping actions (e.g., create/update cart and customer-related actions) through Shopify GraphQL APIs, with session persistence via Redis and chat history via MongoDB. Includes a Shopify Theme Extension for UI embedding and a FastAPI backend with Docker-based deployment. Mentions an MCP server in the architecture diagram but provides no MCP server endpoint or tooling details in the README.

genealogy-research

A Claude Code “skill” that guides systematic genealogy research using Genealogical Proof Standard (GPS): analyzes historical documents (including handwritten, multi-language), helps manage an Obsidian vault (People/Places/Documents/Events, with cross-references and PROCESS.md), recommends sources/databases by time/region, handles naming/language variations, and supports GEDCOM import/export.

GLaDOS

GLaDOS is an on-device (Python) voice assistant/agent framework that combines speech recognition, voice activity detection, text-to-speech, vision processing, an LLM core, and an MCP-based tool system to enable proactive/autonomous behavior (e.g., responding to camera/audio/time events) with long-term memory and configurable LLM backends (e.g., Ollama or OpenAI-compatible APIs).

hasmcp-ce

HasMCP-CE (HasMCP Community Edition) converts existing API endpoints described by OpenAPI/Swagger (and/or manually selected endpoints) into an MCP (Model Context Protocol) server that can be run self-hosted. It provides OAuth2 authentication options, endpoint toggling per MCP server, optional proxy header handling to the upstream API, token management, and logging/analytics for MCP tool calls.

mcp-graphiti

Provides an MCP (Model Context Protocol) server setup for Graphiti-based knowledge graph extraction and storage in Neo4j. It adds a CLI that generates a root MCP server plus multiple project-specific MCP servers (via Docker Compose) so multiple knowledge graphs can share the same Neo4j database while staying isolated by project configuration.

strava-activity-mcp-server

An MCP server package intended to let an AI agent access Strava activity data by exposing MCP tools/endpoints for querying and retrieving Strava activities (e.g., listing activities, fetching activity details), likely using Strava’s API and an OAuth-based connection.

wolfram-alpha-mcp-server

MCP server wrapper for Wolfram|Alpha, exposing Wolfram|Alpha capabilities as MCP tools so AI agents can query for mathematical/scientific answers via the MCP protocol.

colab-mcp

Colab-mcp is a Python MCP server intended to let an MCP-capable agent interact with Google Colab (e.g., to run or manage Colab-related actions). It’s distributed as a CLI script (colab-mcp) and is designed to be launched by an MCP client configuration (mcp.json-style).

gpt-oss

gpt-oss is a Python repository providing reference inference implementations and tool/client examples for OpenAI’s open-weight gpt-oss models (gpt-oss-20b and gpt-oss-120b). It includes local inference via PyTorch, optimized (reference) Triton, and Apple Silicon Metal (reference), plus “harmony” response-format tooling and reference implementations of model tools (browser and python) and a sample Responses-API-compatible server.

mcp-reddit

Provides an MCP (Model Context Protocol) server with tools to fetch and analyze Reddit content such as hot threads and detailed post content (including comments) across post types.

qweather-mcp-server

Provides an MCP server that exposes QWeather (weather) data to AI agents via MCP tools, enabling agent-driven weather lookups (e.g., forecasts/current conditions) without the agent directly calling external APIs.

toolbase

Toolbase is a macOS desktop application that helps users discover, install, and manage tools/plugins for Claude and other AI platforms using the Model Context Protocol (MCP). It consists of an Electron desktop app (UI and tool management) and a local runner (built with Deno) that executes MCP servers locally to provide tools to Claude Desktop.

wellarchitected-mcp-server

MCP server package ("wellarchitected-mcp-server") intended to expose capabilities to LLM agents via the Model Context Protocol. It likely provides tools related to AWS Well-Architected guidance, but no repository contents were provided here to confirm exact tools or behavior.

Grapheteria

Grapheteria is a Python framework for building and orchestrating agent workflows with a structured model, offering both a code-style API (nodes and edges) and a UI that stays in sync for visual design/debugging, plus features like state tracking, logging, time-travel debugging, and production-oriented execution/scale concepts.

neuralangelo

Neuralangelo is an official implementation for high-fidelity neural surface reconstruction, built on the NVIDIA Imaginaire library. It provides training and inference (including isosurface/mesh extraction) for reconstructing a 3D surface from images/video with known camera poses.

orange-mcp-server-snowflake

orange-mcp-server-snowflake is an MCP server intended to let an agent connect to Snowflake and perform common Snowflake operations through MCP tools (e.g., issuing SQL/queries and returning results).

xlwings-mcp-server

Provides an MCP server wrapper/integration for xlwings, enabling an agent to interact with Excel (via xlwings) through MCP tools.

askimo

Askimo is a local-first AI desktop app and CLI that connects users to multiple LLM providers (cloud and local), supports persistent chat sessions stored locally (SQLite), performs document/code search with hybrid RAG (BM25 + vector), integrates MCP tools (via stdio or HTTP), and can run scripts (Python/Bash/JavaScript) from the chat. It claims local-only telemetry (token/cost/RAG performance) with data kept on disk.

cadre-ai

Cadre-AI is a voice-controlled AI agent that streams audio via WebSockets to a FastAPI server, uses Gemini Live for real-time speech and tool orchestration, and executes actions through MCP toolsets (financial data, web search/weather, and optionally Revit integration via a named-pipe proxy). It supports a local mode (including Revit when enabled) and a Cloud Run mode (Revit disabled).

open-multi-agent-canvas

Open Multi-Agent Canvas is an open-source multi-agent chat UI built with Next.js/LangGraph/CopilotKit that lets users manage multiple agents in one conversation and connect a built-in “MCP Agent” to MCP-compatible servers (e.g., via Standard IO or SSE).

PaddleSpeech

PaddleSpeech is an open-source Python toolkit for building speech/audio systems. It provides training, inference, and deployment modules for tasks such as speech recognition (including streaming ASR), text-to-speech (including streaming TTS), punctuation restoration, speaker verification, keyword spotting, speech translation, audio classification, and related speech frontends (e.g., Chinese text normalization/G2P).

wzzotero-mcp-server

An MCP server package intended to provide Zotero-related capabilities to AI agents via the Model Context Protocol, likely allowing tools to read/search/create Zotero items and metadata.

zed-mcp-server-tavily

Provides an MCP (Model Context Protocol) server wrapper for Tavily, intended to be used as a Zed context server. It requires a Tavily API key for authentication and delegates retrieval/search capabilities to Tavily via the underlying Tavily MCP implementation.

claude-ecom

claude-ecom is a Claude Code skill/tool that converts an ecommerce/sales orders CSV into a structured KPI analysis (multiple time horizons, KPI decomposition, health checks) and then uses Claude to write a single consolidated REVIEW.md with prioritized findings and a concrete next-action plan.

mcpServer

Provides an MCP server implementation (based on mcp-go) that currently exposes weather-related capabilities backed by the HeFeng (和风天气) API. Includes a custom JSON unmarshal approach to transfer annotation tags into each result field's description to improve AI interpretability of responses.

pangerl-mcp-server-weather

An MCP server (weather) that likely exposes weather-related tools/data to AI agents via the Model Context Protocol. The repository name suggests it wraps a weather provider API and offers agent-invokable functions, but no manifest/README contents were provided here to confirm exact tools, parameters, endpoints, or provider used.

scira-mcp-chat

Scira MCP Chat is a Next.js-based web UI chatbot that connects to Model Context Protocol (MCP) servers. It supports HTTP and SSE transports for MCP tool access and integrates with multiple LLM providers via Vercel's AI SDK, offering streaming responses and a settings UI for adding/enabling MCP servers.

danghuangshang

danghuangshang is an openclaw-based multi-agent collaboration system (AI “court”) that dispatches tasks across role-specific agents (e.g., 内阁/六部/都察院 style) via chat platforms like Discord/Feishu and can also do GitHub code review workflows. It provides scripts for installation, regime switching (ming/tang/modern), memory persistence/backup, a web dashboard, and various integrations/tools.

Gearlynx

Gearlynx is a cross-platform Atari Lynx emulator with a built-in debugger and an embedded MCP server (stdio or HTTP) intended to support AI-assisted debugging and tooling. It also supports a libretro core.

harlequin

Harlequin is a terminal-based SQL IDE (TUI) implemented in Python. It provides an interactive interface to author, run, and browse/query data using pluggable database adapters (e.g., DuckDB default, SQLite, Postgres/MySQL via optional adapter packages).

MaxKB

Open-source enterprise AI agent platform that combines RAG (retrieval-augmented generation) with agentic workflows and MCP tool-use support. Enables document upload, web crawling, automatic text segmentation and vectorization, and zero-code integration into existing business systems for intelligent Q&A. Supports multiple LLM backends including DeepSeek, Llama, Qwen, OpenAI, Claude, and Gemini.

mcp-crash-course

mcp-crash-course is an educational repository that teaches the Model Context Protocol (MCP) via a set of hands-on project topics organized in git branches (e.g., SSE, LangChain adapters, Docker containerization, and MCP prompts). It is not presented as a production API/service; it provides learning materials and sample implementations around MCP.

mcp-server-google-bigquery

Provides an MCP server that connects an agent to Google BigQuery so the agent can perform BigQuery operations (e.g., query execution and related data access) via MCP tool calls. The package name indicates BigQuery-specific MCP functionality.

NDepend.MCP.Server

NDepend.MCP.Server is an MCP (Model Context Protocol) server package intended to expose NDepend functionality to AI agents via MCP tools/handlers so agents can query and work with .NET code analysis results.

python-ai-kit

python-ai-kit is a project template/boilerplate for generating production-oriented Python applications for AI agents (including multi-agent orchestration and state), MCP servers, and FastAPI-based microservice/monolith APIs. It emphasizes observability, testing/evaluation pipelines, prompt versioning, and (in template features) security practices like encrypting API keys.

ragflow-mcp-server-aider

ragflow-mcp-server-aider is an MCP server wrapper for RAGFlow, intended to expose RAGFlow capabilities (e.g., retrieval/knowledge-base style operations) to an MCP-capable agent such as Aider. The name suggests it is specifically packaged for agent workflows rather than a public REST API product.

scrapy-mcp-server

scrapy-mcp-server is an MCP server intended to help AI assistants inspect and debug Scrapy spiders and automatically generate fixes when scraping breaks (e.g., selector changes, A/B layout variants, and anti-bot changes). The README frames a workflow where monitoring/CI triggers the MCP-based debugging and produces a pull request with updated spider logic.

Search-R1

Search-R1 is an open-source reinforcement learning (RL) framework for training “reasoning-and-searching interleaved” LLMs. It supports RL methods (e.g., PPO/GRPO/reinforce), multiple base LLMs, and pluggable search/retrieval engines (local sparse/dense retrievers and online search). It also supports launching a separate local retrieval server that the LLM can call via an HTTP search/retrieve API during training/inference.

zed-mcp-server-2slides

Provides a Zed editor MCP (Model Context Protocol) server extension that wraps the external 2slides-mcp MCP server, exposing tools to generate slide decks and to query available themes and job status/results.

bitcoin-mcp-server

An MCP (Model Context Protocol) server that exposes LLM-callable capabilities to track Bitcoin prices by calling the CoinGecko API (api.coingecko.com/api/v3).

DB-GPT

DB-GPT is an open-source agentic AI data assistant that connects to data sources (databases, CSV/Excel, documents/knowledge bases), uses an LLM to generate SQL and Python/code for analysis, executes workflows (including reusable “skills”) and produces reports/charts, with an emphasis on sandboxed execution for code/tools.

gorse-server

gorse-server is the server component for Gorse, an open-source recommendation system. It typically provides APIs and serves recommendation results (and related indexing/training workflows) backed by a datastore.

human-skill-tree

human-skill-tree is an open-source “skill tree” that provides a curated set of AI agent skills (prompt/config templates) to transform general chat/code assistants into structured, cognitive-science-inspired learning companions (e.g., Socratic tutoring, active recall, spaced repetition). It also includes a web demo/classroom app built with Next.js + Vercel AI SDK + Supabase.

mcp-server-aws-kb-retrieval

An MCP server that performs retrieval over AWS Knowledge Bases (KB) and returns relevant knowledge-base content to an MCP-capable agent/tooling workflow.

ragflow-mcp-server

An MCP server package that exposes RagFlow-related capabilities to MCP-compatible AI agents, allowing agents to query or interact with RAG/RagFlow functionality via the MCP protocol.

spacy-server

spacy-server is a service wrapper for spaCy that exposes spaCy NLP capabilities over a network interface (typically as an HTTP API) so other applications can send text and receive NLP annotations.

zed-mcp-server-basic-memory

Provides a Zed Editor context-server integration that connects Zed Assistant to Basic Memory via a MCP server ("basic-memory"). It is configured through Zed settings and optionally selects a Basic Memory project for storing Markdown-based notes.

anet-mcp-server

Anet MCP Server is a Rust-based implementation of an MCP (Model Control Protocol) server that exposes JSON-RPC 2.0 methods for tools, prompts, and resources. It uses a NATS transport layer for message passing and an async framework (Tokio) for handling requests.

stock-modelscope-mcp-server

An MCP (Model Context Protocol) server package intended to expose functionality related to “stock-modelscope” models/tools to MCP-compatible agents. Based on the provided package name only, it likely lets an agent query stock-related model outputs through MCP tools.

swarms

Swarms is a Python multi-agent/orchestration framework for building “swarm” workflows using LLMs. The README shows usage via a Swarms class that accepts an OpenAI API key and runs a high-level objective through the swarm.

mcp-server-alpha-vantage

MCP server intended to provide programmatic access to Alpha Vantage (AlphaVantage.co) stock/market data for use by MCP-capable agents.

mcp-server-jina-java

Provides an MCP server (stdio/transport) that uses Jina Reader API to (1) search the web and return SERP results and (2) read a given URL and fetch its content.

mcp-swiftie-server

mcp-swiftie-server is a demo Model Context Protocol (MCP) server written in Go that exposes a small set of MCP tools to query mock Taylor Swift-related data (albums, songs, tours) using in-memory data. It includes a WebSocket listener (port 9000), a simple health endpoint and metrics endpoint, and demonstrates synchronous tool calls as well as a streaming/batched query pattern.

orange-mcp-snowflake-server

Provides an MCP server that connects an agent/workflow to Snowflake, enabling natural-language-to-SQL and/or database tool actions via the MCP interface (based on the package name).

QCX

QCX (Quality Computer Experience) is a web app built with Next.js and Vercel AI SDK that combines LLM-driven text streaming/generative UI with mapping (Mapbox) and retrieval/search (Tavily/Exa per README) plus a serverless database (Upstash Redis). It appears aimed at an interactive, map-centric experience powered by configurable generative models.

yby6-video-mcp-server

An MCP server package intended to expose video-related capabilities to AI agents via the Model Context Protocol (MCP).

AIGC-Claw

AIGC-Claw is an end-to-end AI video generation system built around the OpenClaw platform. It turns a user’s idea into a complete video through a six-stage workflow: script generation, character design, storyboard/shot planning, reference image generation, video generation (image-to-video and text-to-video), and post-editing/assembly with transitions. It supports interactive user confirmation at each stage and multiple third-party model providers (e.g., DashScope, Seedream, Jimeng, Kling, DeepSeek, OpenAI, Gemini).

CanvasMCPClient

Canvas MCP Client is a self-hostable infinite, zoomable, pannable canvas dashboard that integrates with multiple MCP (Model Context Protocol) servers and provides a widget-based interface (e.g., chat, notes, kanban, spreadsheet) plus configurable AI provider support via a FastMCP-based backend (FastAPI).

codeql-mcp

Runs a Model Context Protocol (MCP) server (via FastMCP) that wraps a CodeQL query server, exposing tools to register CodeQL databases, run CodeQL queries, decode .bqrs files to JSON, and locate predicate/class symbol positions.

lingua

Meta Lingua (lingua) is a minimal, research-focused LLM training and inference codebase built on PyTorch, providing reusable components (models, data loading, distributed training, checkpointing, profiling) and example “apps” and configuration templates for end-to-end training/evaluation on SLURM or locally (e.g., via torchrun).

mcp-server-bankless-onchain

An MCP server intended to provide AI agents with bankless/onchain-related capabilities via the Model Context Protocol. Specific tool endpoints, data sources, and operational behavior are not provided in the prompt, so the evaluation focuses on interface/security/reliability that can be inferred from the package name/type (MCP server) rather than concrete implementation details.

mcp-server-with-spring-ai

Provides Spring Boot integration for building an MCP (Model Context Protocol) server/client in Java using the MCP Java SDK. The example described exposes MCP tools that query a PostgreSQL database, and a client uses an LLM to select and invoke the appropriate tool.

recursive-decomposition-skill

A Claude Code skill/plugin that applies recursive decomposition strategies (filtering, chunking, parallel sub-agenting, verification, and synthesis) to improve handling of long-context tasks such as multi-file codebase analysis and multi-document aggregation.

spring-ai-mcp-server-demo

A Docker-compose demo microservices platform (Orders, Payments, Incidents, and an AI Assistant) where Spring Boot REST APIs persist business data and are exposed to AI agents via Model Context Protocol (MCP) servers, configured for use in tools like VS Code MCP integration.

Atla

Archived MCP server that provided a standardized interface for LLMs to interact with the Atla API for LLMJ evaluation. The Atla API is no longer active (archived July 21, 2025).

mastering-langgraph-agent-skill

A Python educational skill/repository that teaches common LangGraph patterns for building stateful, tool-using, multi-step AI agents (including persistence/memory, human-in-the-loop, and multi-agent workflows), with a focus on agent “Agent Skill Standard” packaging and deployment guidance.

ragflow-retrieval-mcp-server

ragflow-retrieval-mcp-server is an MCP (Model Context Protocol) server intended to provide retrieval capabilities (e.g., querying a RAG/knowledge base) to AI agents via MCP tools.

zeroclaw

ZeroClaw is a local-first, single-binary Rust personal AI assistant you run on your own devices. It provides a gateway/control plane with a web dashboard to manage an always-on assistant that can connect to multiple chat/communication channels (e.g., WhatsApp/Telegram/Slack/Discord/Signal/Email/Matrix/IRC/etc.), integrate with hardware peripherals (e.g., ESP32/STM32/Arduino/Raspberry Pi GPIO), and run autonomous/"hands" workflows, SOPs, and tools (including mentions of MCP and many integrations).

chatgpt-retrieval-plugin

A self-hosted Retrieval-Augmented Generation (RAG) backend that exposes a FastAPI service for semantic search over user-provided documents. It chunks documents, creates embeddings via OpenAI, stores/query them in a chosen vector database provider, and serves query/upsert/delete endpoints intended to be used as a ChatGPT Retrieval Plugin backend (and for custom GPT actions/function calling).

claude-ads

Claude Ads is a Claude Code skill that audits and helps optimize paid advertising accounts. It runs multi-platform and single-platform checks (Google, Meta, YouTube, LinkedIn, TikTok, Microsoft/Bing, Apple Search Ads) using exported/pasted data, producing a prioritized action plan and an Ads Health Score. It also provides industry templates and strategic planning commands; live landing page analysis may use Playwright.

deeplake

Deep Lake is an AI data runtime/database implemented as a Python package and storage format for deep-learning workloads. It stores multimodal data (text, images, audio, video, etc.) alongside vectors/embeddings, supports streaming to ML frameworks (e.g., PyTorch/TensorFlow), and provides dataset versioning/lineage with integrations to common AI tooling (e.g., LangChain, LlamaIndex, W&B).

mcp-linkedin

An MCP (Model Context Protocol) server that exposes tools to interact with LinkedIn Feeds and LinkedIn Jobs using an unofficial LinkedIn API wrapper.

readwise-skills

readwise-skills is a repository of AI agent “skills” for working with a user’s Readwise/Reader data. It includes skills that teach an agent how to use the Readwise CLI and Readwise MCP tools, plus higher-level workflows like triaging saved articles, feed catch-up, quizzes, book reviews, reading recaps, and generating a “now reading” page/persona for personalization.

zmp-knowledge-store-mcp-server

MCP server intended to expose a “knowledge store” for use by AI agents via the Model Context Protocol. It likely provides tools for adding, retrieving, or searching knowledge/data, backed by some persistence layer.

mcp-server-brightdata

An MCP (Model Context Protocol) server package intended to integrate with Bright Data (web data/infrastructure) so an agent can perform Bright Data-related tasks through MCP tools.

media-skills

media-skills is a collection of open-source “Agent Skills” for OpenClaw/Claude Code and other agents that follow the Agent Skills standard. It includes multiple skills for media/content creation such as image generation, audio/TTS/music/voice cloning, and video post-production/prompting/video generation, aiming for “zero API key management.”

CoWork-OS

CoWork OS is a local-first desktop “AI operating system” (macOS/Windows) for running agent workflows and automations across many LLM providers and messaging channels, with a focus on security hardening, approvals for destructive actions, sandboxing/guardrails, encrypted local storage, and extensive built-in skills/connectors (including MCP connectors).

orange-unsplash-mcp-server

orange-unsplash-mcp-server is an MCP server package intended to integrate with the Unsplash API to provide AI agents with access to Unsplash resources (e.g., searching or retrieving images) through MCP tools.

skills

PANews Agent Toolkit provides an agent “skills” bundle (and Codex/Claude plugin bundle layout) containing skills for: (1) structured PANews crypto/blockchain news discovery, (2) PANews creator workflows that require an authenticated user session, and (3) reading PANews pages and converting them to agent-ready Markdown.

unsplash-mcp-server

Provides an MCP (Model Context Protocol) server (Java/Spring-stdio) that can search images on Unsplash, using an Unsplash access key supplied via environment variable.

web-scraping-mcp-server

An MCP (Model Context Protocol) server that provides web-scraping capabilities to an AI agent, enabling the agent to fetch and extract content from web pages via MCP tool calls.

cartola-mcp-server

cartola-mcp-server is an MCP server intended to provide access to data/operations for the Fantasy Game Cartola FC (as indicated by its repository description/metadata).

go-passage-of-time-mcp-server

Provides an MCP server (Go) that lets an LLM do basic “passage of time”/time-related operations, inspired by a similar Python MCP server. Can run as an stdio MCP server by default, or as an HTTP streamable server when given a port.

ham

HAM (Hierarchical Agent Memory) is a Claude Code skill that reduces AI context/token usage by replacing a single large CLAUDE.md with smaller, directory-scoped CLAUDE.md files and local memory files (e.g., .memory/decisions.md, patterns.md). It auto-scans a project and routes the agent to read only relevant context for the directory being worked in, and provides commands for setup, updating, routing, and local dashboard/analytics.

verl

verl is an open-source reinforcement learning (RL) training library for large language models (LLMs). It provides a flexible HybridFlow-style programming model to compose RL post-training dataflows (e.g., PPO/GRPO/ReMax/RLOO/REINFORCE++ and other recipes), and integrates with common LLM training/inference stacks (FSDP/FSDP2/Megatron-LM for training; vLLM/SGLang/HF Transformers for rollout generation).

wolfram-alpha-mcp-server-xiaomayisjh

An MCP server package intended to provide Wolfram Alpha query/answer capabilities to MCP-capable agents by exposing Wolfram Alpha functions as MCP tools.

awesome-oceanbase-mcp

A collection of Python MCP servers intended to provide AI assistants with controlled access to the OceanBase ecosystem (e.g., querying/managing OceanBase, integrating with OceanBase Cloud Platform/OBCloud, and operational tooling).

jetski

Jetski is an open-source MCP analytics and authentication platform. It deploys/manages an MCP gateway (mcp-gateway) that sits in front of an existing MCP server to provide zero-code authentication, prompt/tool usage analytics, and real-time debug logs/visibility, plus auto-generated setup instructions for MCP clients. Jetski is designed to work with the MCP Model Context Protocol ecosystem without requiring changes to the MCP server itself.

life-sciences

“life-sciences” is a Claude Code marketplace entry that installs MCP servers and domain-specific skills for life-sciences workflows (e.g., PubMed, BioRender, Synapse, Wiley Scholar Gateway, and a 10x Genomics Cloud local MCP). It also provides guidance on plugin installation and post-install credential configuration.

mcphost-server

mcphost-server is a Go-based server intended to bridge MCPHOST to local LLMs (e.g., Ollama) via HTTP. It can run in a default server mode exposing HTTP endpoints and can be configured via environment variables, an mcp.json configuration file, and command-line flags.

mcp-server-cat-api

An experimental MCP server (Rust) that exposes a cat “breeds” search route (and currently only that route per the README).

mlflow-server

mlflow-server is the server component of MLflow, providing an HTTP API to manage machine learning experiments, runs, artifacts, models, and the tracking/registry services.

opencompass

OpenCompass is an open-source LLM evaluation platform. It provides configurable evaluation pipelines (via CLI and Python scripts) to run model benchmarks across many datasets, including support for local/open-source models and API-based models (e.g., OpenAI/Qwen), with optional inference acceleration backends (e.g., vLLM, LMDeploy).

shuidi-data-mcp-server

An MCP (Model Context Protocol) server wrapper intended to expose “shuidi” (shuidi-data) data access to AI agents via MCP tools. The provided prompt does not include README/repo contents, so the exact tools, endpoints, parameters, and operational behavior cannot be verified from the given information.

skywalking-oap-server

SkyWalking OAP Server (Observability Analysis Platform) ingests, processes, and stores distributed tracing/metrics/logging data for Apache SkyWalking. It serves as the backend that receives telemetry from agents/collectors, performs analysis/aggregation, and provides data access for the SkyWalking UI/other consumers.

zheng-mcp-gaodeweather-server

MCP server that provides Gaode (AMap) weather functionality to agents via Model Context Protocol tools (exact weather endpoints/fields are not provided in the supplied prompt).

q-mem-mcp-server

q-mem-mcp-server is an MCP server package intended to expose “memory” (likely a Q-* memory component) to an MCP-capable agent runtime via the Model Context Protocol.

wavefront

Wavefront is an open-source enterprise AI middleware platform for building production-ready AI applications: it provides a unified API layer for agents/workflows, connectors to data and LLMs/SLMs, authentication/authorization (incl. SSO), and observability/monitoring/evaluation for agent and workflow execution.

eMCP-Nexus

eMCP Nexus is described as an AI-powered marketplace for Model Context Protocol (MCP) tools, offering semantic discovery (FAISS + embeddings), recommendations, a RAG chatbot for support/troubleshooting, GitHub-based tool deployment/indexing, and pay-per-task execution with payments via Stripe and/or crypto, with dashboards/portals for creators and users.

mcp_server

CPP MCP-SERVER is a C++ Model Context Protocol (MCP) server that supports multiple transports (stdio, SSE, and HTTP Stream) and a pluggable module/plugin architecture for extending MCP capabilities (resources, tools, prompts, etc.).

mem0-api-server

mem0-api-server is a server-side API package for the mem0 system (memory layer). It exposes HTTP endpoints to create/update and query stored memory, typically backed by a vector/database layer and (depending on configuration) an embedding and/or LLM pipeline.

rasesql-mcp-server

Provides an MCP server for SQL-related assistance (rasesql) so an AI agent can interact with a SQL engine/workflow via MCP tools. Used to let agents translate/plan SQL tasks and fetch results through a standardized tool interface.

sleeper-mcp-server

Sleeper MCP Server is an MCP (Model Context Protocol) server that lets an AI agent query Sleeper Fantasy Football data (e.g., league standings, members, weekly matchups) and apply custom league settings such as head-to-head tiebreaker calculations defined in a local configs/league_settings.json file.

stockchart-mcp-server

MCP server package that (per its name) exposes stock chart / market data charting capabilities to AI agents via the Model Context Protocol, likely providing tools such as fetching price/time-series data and returning chart-ready responses.

stocktrim-mcp-server

stocktrim-mcp-server is an MCP server package intended to expose stock-trimming / stock-analysis related functionality to AI agents via the Model Context Protocol (MCP).

vercel-mcp-server-for-zed

Provides an MCP server for the Zed editor that connects the editor’s AI assistant to AWS services (e.g., S3, DynamoDB, Lambda) using user-supplied AWS credentials and region.

go-mcp-server-financeiro

Provides a simple Model Context Protocol (MCP)-oriented server (implemented in Go) that lets clients register and list “financial tools”, query stock prices via the Alpha Vantage public API, and fetch server metadata via a /metadata endpoint.

mcp-llama3-client

Provides a Python client application that connects to an MCP Flight Search server over HTTP and uses an Ollama-hosted Llama 3.2 model to provide a user-friendly natural-language flight search interface (using MCP tools such as a flight search tool and a server status tool).

mcp-manager

Provides a client-side web UI (React/Vite) for configuring and managing MCP (Model Context Protocol) servers to be used with the Claude Desktop app on macOS, including one-click commands and environment-variable/server configuration for multiple popular MCP integrations.

superset-mcp-server

An MCP server package that exposes Apache Superset functionality to AI agents via the Model Context Protocol (MCP).

thesis-figure-skill

A Claude Skill that converts pasted thesis/paper text or uploaded images into publication-ready diagrams, primarily generating LaTeX/TikZ code or draw.io XML. It claims to run compile/visual checks and iterate until a scored quality target is met.

Ethereum-Trading-MCP-Server

Provides a Rust-based Model Context Protocol (MCP) server for querying Ethereum balances, fetching token prices via Chainlink, and simulating/performing Uniswap V2-style token swaps using an Ethereum RPC provider and a private key configured via environment variables.

multimodal-mcp-client

multimodal-mcp-client is an early-access, Vite/TypeScript (React/NextUI) web client that provides a voice-first UI to orchestrate agentic workflows using the Model Context Protocol (MCP). It integrates multimodal input (voice/text/visual), Google Gemini capabilities, and MCP servers (either Systemprompt-provided servers configured via a Systemprompt API key or custom MCP servers via a local config file).

mysql-mcp-server

Provides an MCP (Model Context Protocol) server that exposes MySQL metadata and query capabilities to AI assistants. Built with Quarkus and supports MCP connectivity via SSE (/mcp/sse) and a streamable HTTP endpoint (/mcp) over an HTTP listener.

openvino-model-server

OpenVINO Model Server exposes OpenVINO-IR (and related) models over an HTTP API to run inference, typically supporting multiple backends/devices (e.g., CPU/GPU/VPU) and model variants for deployment.

bilibili-mcp-server

Bilibili-focused MCP Server (Go) that can run over SSE or stdio, providing AI-accessible tools for querying user information, fetching latest followed content (requires login), and searching videos.

prebid-server

prebid-server (PBS) is an open-source auction server for Prebid.js that provides ad server interoperability: it receives bid requests from a client, routes them to configured bidder adapters, normalizes/validates bid responses, and returns compatible bids to the publisher in the format expected by ad servers.

pydmnrules-mcp-server

Provides an MCP server (MCP = Model Context Protocol) for the pydmnrules rule-engine library, enabling an AI agent to interact with DMN rules context and operations via MCP tools.

agience-core

Agience Core is an open, extensible runtime for agentic AI centered on shared, typed, versioned “artifacts” with provenance and human-in-the-loop workflows. It is positioned as both an MCP server (exposing tools) and an MCP client (consuming vendor MCP servers), and emphasizes capability-based access via scoped API keys and delegations tracked by authority/provenance.

ContextOS

ContextOS is a Python-based “context intelligence” platform that provides a unified MCP (Model Context Protocol) server and a CLI, aiming to orchestrate retrieval, memory, and reasoning layers for AI agents (e.g., cognition primitives, churn-aware retrieval routing, and index lifecycle management).

nothumanallowed

Command-line and locally-run AI-agent platform with many “specialist” agents plus a REST API for invoking agents/agent chains; includes integrations for Gmail/Calendar and Outlook, a local web UI, optional voice chat, and an extensibility/plugin system. Claims “zero data” via local processing and supports LLM calls using user-provided API keys.

oreilly-ai-agents

A collection of educational notebooks and example code for learning how to build and deploy AI agents (single-agent and multi-agent patterns) using popular Python frameworks (e.g., LangChain/LangGraph, CrewAI, AutoGen, SmolAgents) and integrating tools such as MCP, along with evaluation-oriented notebooks.

youtubeinsights-mcp-server

youtubeinsights-mcp-server is an MCP (Model Context Protocol) server intended to provide AI agents access to YouTube-related insights/data. It likely exposes MCP tools that let an agent query analytics/insights for YouTube channels/videos, but the provided prompt includes no README/repo contents to confirm specific endpoints, tool names, parameters, or authentication flow.

Kaimon.jl

Kaimon.jl is a Julia package for computing/using monads and related functional programming abstractions (e.g., monadic operations and transformer-style composition) in the Julia ecosystem.

polardb-mysql-mcp-server

polardb-mysql-mcp-server is an MCP (Model Context Protocol) server that exposes tools for working with PolarDB MySQL, enabling an LLM/agent to execute database-related operations via MCP tool calls.

siemens-graph-studio-mcp-server

The package provides an MCP (Model Context Protocol) server that connects an AI agent to Siemens graph-related capabilities, enabling the agent to query or manipulate Siemens graph/knowledge data through MCP tools.

Agentic-SEO-Skill

An LLM-first, agentic SEO analysis skill for Antigravity, Claude Code, and Codex. It orchestrates multiple specialist sub-skills (technical SEO, content/E-E-A-T, performance/CWV, schema, sitemap, visual checks, links, GEO/AEO, entity SEO, hreflang, programmatic safeguards, plus GitHub repo SEO/benchmarking) to collect evidence from target URLs (and optionally run verification scripts) and generate structured audit outputs and prioritized action plans.

AI-News-Briefing

Automates a daily AI-related news research pipeline using the Claude Code CLI in headless mode. It performs web searches across multiple topics, compiles a two-tier briefing (TL;DR + full report), publishes the result as a page in a Notion database via Notion MCP, and optionally sends a formatted summary card to Microsoft Teams and/or Slack via webhook(s).

mcp-server-chart

mcp-server-chart is an MCP server package intended to expose charting-related capabilities to AI agents via the Model Context Protocol (MCP). Without repository/README/package-manifest contents, the specific tools, inputs/outputs, and supported chart formats cannot be verified.

mcp-servers

Provides MCP (Model Context Protocol) server configurations intended to integrate an agent host with OpenAI (o1 preview) and a Flux image model via separate MCP servers, configured through environment variables and a simple example client config.

arxiv-mcp-server

Provides an MCP-based server (and associated client CLI) for searching, retrieving, analyzing, and exporting arXiv paper metadata and related citation/trend insights in multiple formats (e.g., BibTeX/RIS/JSON/CSV/YAML), with a REST API and a web UI described in the README.

awesome-openclaw-agents

awesome-openclaw-agents is a curated collection of copy-paste ready OpenClaw agent templates (SOUL.md configurations) plus a quickstart and machine-readable agent listing (agents.json). It also references an MCP servers section and an external deployment/creation flow via CrewClaw, but the provided README content does not include concrete API/MCP technical specifications for the repository itself.

mcp.science

mcp.science is an MCP server package intended to expose “science” related tools/data to an AI agent via the Model Context Protocol (MCP). Specific tool capabilities, endpoints, and behavior are not provided in the prompt content, so the evaluation is based only on the package name/declared MCP nature.

OpenManus-RL

OpenManus-RL is a Python-based RL tuning/finetuning codebase for agentic LLM systems, paired with an OpenManus-RL dataset of agent trajectories. It positions Verl (Volcano Engine Reinforcement Learning) as the primary RL training framework (e.g., PPO/DPO/custom reward modeling) and includes environment setup scripts for benchmarks such as WebShop and ALFWorld.

puzzle-academy-mcp-server

MCP server package intended to expose “Puzzle Academy” capabilities to AI agents via the Model Context Protocol (MCP). Based on the provided package name only, the exact tool set, configuration, and endpoints are not verifiable from the prompt.

roboflow-inference-server-gpu

roboflow-inference-server-gpu is a GPU-oriented inference server implementation intended to run Roboflow models and expose an inference API for computer-vision predictions.

stable-audio-tools

Provides training and inference code (primarily Python/PyTorch + PyTorch Lightning) for conditional audio generation models, including a Gradio-based demo runner for loading Hugging Face pretrained checkpoints and running local training scripts driven by JSON config files.

open-mcp-server

Open-MCP-Server is a Java service framework that implements Model Context Protocol (MCP) support and provides a configurable bridge to multiple backend/API types (e.g., REST/gRPC/Dubbo/SOAP). It also exposes endpoints for AI assistant/session chat and for invoking MCP-style tools, plus management and code-generation utilities.

tripo-mcp

Provides an MCP (Model Context Protocol) server that integrates AI assistants with Tripo for generating 3D assets from natural language and importing the results into Blender (currently focused on Tripo Blender Addon integration).

aws-bedrock-mcp-client-server

Spring Boot (deployed on AWS Lambda behind API Gateway) that exposes a REST API to interact with Amazon Bedrock models and leverages MCP-style tool use for tasks such as calculations, weather retrieval (via external weather API), and converting web pages to markdown; includes CDK/IAM provisioning.

mcp-server-useful-tools

Provides an MCP server offering “Weather MCP” and “Stock” tools via a local SSE endpoint (example: http://127.0.0.1:8080/sse). Weather and stock examples are shown in the README output format (city/conditions; real-time stock quote details).

mlflow-server

mlflow-server refers to running MLflow’s tracking server (typically MLflow Tracking + optional artifact store integration). It provides HTTP endpoints for creating and managing experiments, runs, metrics, parameters, and artifacts.

rest-mcp-server

A Java/Spring Boot integration that auto-exposes Spring REST controller endpoints as Model Context Protocol (MCP) tools, mounted into the app (SSE endpoint at /sse).

xiaocaiji-text1-mcp-server

An MCP server package named xiaocaiji-text1-mcp-server, intended to expose text-related capabilities to an MCP-capable agent. However, no README/repo content was provided in the prompt, so specific tools, behaviors, endpoints, and configuration details cannot be verified.

5ire

5ire is a cross-platform desktop AI assistant that acts as an MCP client for connecting to Model Context Protocol (MCP) servers, and it also includes a local knowledge base (RAG) and other productivity features like prompt libraries, bookmarks, search, and usage analytics. Tools capability is provided via MCP servers; local knowledge base embeds and indexes documents locally.

buyer-eval-skill

A free open-source Claude skill that evaluates B2B software vendors by prompting for buyer context, conducting domain-expert question exchanges, optionally engaging vendor AI agents via the Salespeak Frontdoor API, cross-referencing claims against independent sources, and producing a comparative, evidence-tagged scorecard plus risk analysis and demo-prep questions.

chat-ui

Chat UI that runs as a single-file HTML front-end (optionally via Docker/Python server) for interacting with LLM backends using OpenAI-compatible request/response formats, including support for multiple response formats, multimodal image input, download/interrupt/retry of chat history, Markdown/original display, i18n, and MCP rendering via a desktop IPC integration.

OpenClaw-Medical-Skills

OpenClaw Medical Skills is an open-source collection of 869 “skills” (each a self-contained SKILL.md module under a skills/ directory) that extend OpenClaw/NanoClaw Claude-based agent workflows for biomedical and clinical research tasks. It primarily operates as a local plugin/skills library (copy/sparse-checkout) rather than a standalone API service.

rhasspy-server

Rhasspy server service for running the Rhasspy voice/NLU pipeline as a web server that exposes endpoints used by the rest of the Rhasspy ecosystem (e.g., for handling requests, configuration, and skills).

mcp-client-server-azure

A Maven multi-module Java (Spring Boot) demo showing an AI client-server architecture using Spring AI with Azure OpenAI. The client exposes a /chat REST endpoint and forwards prompts to the server while propagating headers/context. The server exposes tool endpoints (e.g., user management) and integrates Spring AI's MCP-style tool orchestration, with custom ThreadLocal-based context propagation for async/distributed tracing and request-scoped data.

mlflow-server

MLflow Server (mlflow-server) provides the ability to run MLflow’s tracking backend and related server functionality (e.g., experiment/run tracking endpoints) for model/experiment management, typically deployed as a service behind a web interface/APIs.

pgvector-mcp-server

Provides an MCP (Model Context Protocol) server that exposes operations related to pgvector/pgvector-based vector search, allowing an agent to create/use embeddings-backed search capabilities against a PostgreSQL + pgvector setup via MCP tools.

gimp-mcp

Provides an MCP (Model Context Protocol) integration for GNU Image Manipulation Program (GIMP), enabling AI-driven image editing workflows through an MCP server and a GIMP plugin that exposes commands (e.g., create image/layers, load/save files, set colors/offsets, fill selections).

rt-claw

RT-Claw is an OpenClaw-inspired intelligent assistant for embedded devices. It provides an AI chat engine that calls an LLM over HTTP, supports tool-use via function calling (30+ built-in tools), and includes a framework for skills, memory (RAM + persistent NVS/flash), swarm-style node discovery/remote tool invocation, scheduled tasks, and a UART chat-first shell with /commands. It is designed to run across multiple OSAL targets (FreeRTOS, RT-Thread, Linux) and includes networking components (HTTP client, Ethernet/WiFi).

seedream-server-mcp

seedream-server-mcp is an MCP server package intended to expose Seedream functionality to MCP-capable agents via the Model Context Protocol. Based on the provided package name alone, the exact tools, schemas, and operational behavior cannot be confirmed.

spark_history_mcp_server

Provides an MCP (SSE) server wrapper around an Apache Spark History Server, exposing tools to list and inspect Spark applications/jobs/stages/executors and to compare job environments/performance and identify bottlenecks.

Context-Engineering-for-Multi-Agent-Systems

Provides a code-centric blueprint (mostly notebooks) for building a “universal, domain-agnostic” multi-agent system using a Context Engine with dual high-fidelity RAG, traceable “glass-box” observability, and orchestration via Model Context Protocol (MCP). The repository emphasizes transparency (trace dashboards, execution logs, token/cost analytics) and mentions safeguards such as sanitization and moderation.

xhs-bailian-mcp-server-jlq

MCP server package (Julia-based) intended to expose XHS “bailian” capabilities to an AI agent via the Model Context Protocol.

alpine-llama-cpp-server

A self-hosted server that runs LLaMA via llama.cpp (in an Alpine-based container/image), exposing an HTTP interface for text generation/chat. Intended to download/use local model files and serve inference requests.

mcp-server-java-clima

An MCP server implementation in Java intended to provide a tool interface (via Model Context Protocol) for interacting with “clima” (likely weather/climate-related data or functionality), based on the repository name. Only repository metadata was provided; no README/spec/API details were included to confirm exact capabilities, tools, endpoints, or data sources.

mlserver

mlserver is a Python library/framework for serving machine learning models via a server interface (commonly aligned with the KServe/MLServer-style “MLServer” ecosystem). It provides abstractions to wrap model implementations and run them as inference endpoints.

zhdddd-mcp-knowledge-server

An MCP (Model Context Protocol) knowledge server package that likely exposes knowledge retrieval/tools to MCP-capable agents. (No README/repo contents were provided, so exact functions, tool names, and data sources cannot be verified.)

hinge-profile-optimizer

Provides a structured, research-backed guided process (packaged as Claude Skill content) to help a user audit and improve their Hinge dating profile: questions/interview to discover the user’s voice, photo strategy, prompt/copy writing, settings cleanup, and guidance for implementing changes over subsequent weeks.

pvv-mcp-server

A Python-based MCP server that exposes VOICEVOX text-to-speech capabilities (e.g., generic speaker speak, a specific Metan Aska-style tool, and a speakers list) by wrapping the VOICEVOX Web API using FastMCP.

wxo-bootcamp-mcp-server

Provides an MCP server (Hospital Data MCP Server) that exposes access to an included, entirely fictional hospital dataset via Model Context Protocol. It supports both SSE (server-sent events) and STDIO transports and includes guidance for running and testing with the MCP Inspector.

mcp-server-and-client-with-spring-ai

Provides a demo of a Model Context Protocol (MCP) server and client built with Spring Boot and Spring AI. The server exposes REST endpoints for managing medical patients and reports and integrates Spring AI MCP for context-rich interactions with an AI model; the client consumes the server and provides a client-side UI/endpoints for structured requests/responses.

zk-doc-mcp-server

An MCP (Model Context Protocol) server package intended to expose zk-related documentation/knowledge to AI agents ("zk-doc"). The repository name suggests MCP integration, but no README/package manifest details were provided here to confirm exact tools, endpoints, data sources, or behavior.

crewAI

CrewAI is a Python framework for orchestrating multi-agent (role-based) and event-driven workflows (“Crews” and “Flows”) to automate tasks by coordinating one or more LLM-backed agents with tools and structured configurations (e.g., YAML + Python project scaffolding). It also advertises a related cloud control plane for observability and enterprise management.

mcp-go-server-ak

An MCP-compatible (per description) Go server that exposes vector search functionality backed by Pinecone for storage/indexing and OpenAI for embeddings/processing. It also includes a health endpoint, search/index endpoints, and authentication endpoints under /auth/* (with optional GitHub OAuth for development and an MCP secret token).

nai-kserve-huggingfaceserver

The nai-kserve-huggingfaceserver package provides a KServe server integration for serving Hugging Face models. It is intended to run Hugging Face model inference behind a KServe-compatible endpoint.

youtubeinsights-mcp-server-test

youtubeinsights-mcp-server-test appears to be an MCP server test package for providing YouTube Insights functionality via the Model Context Protocol. No README/repo contents were provided here, so capabilities, endpoints/tools, auth, and behavior cannot be verified from evidence.

poco-claw

Poco is a self-hostable AI agent execution platform/web UI that runs agent tasks in an isolated container, supports project/task management and artifact viewing, and integrates agent tooling via MCP/Skills plus an embedded browser and IM integrations.

callmybot-domoticz

Greet anyone by name with a friendly hello. Explore the origin of 'Hello, World' for context in de…

callmybot-hello-mcp-server

Generate quick, friendly greetings by name. Personalize salutations for any context. Explore the o…

hm_editor

The development version of CKEditor - JavaScript WYSIWYG web text editor.

hermes-agent

Hermes Agent is an AI agent framework/CLI plus a messaging gateway that supports interactive chat (TUI) and multi-platform messaging (e.g., Telegram/Discord/Slack/etc.). It provides tool-calling with a tools/toolsets system, persistent memory/skills, optional cron scheduling, and optional integration with MCP servers. It can run locally or on various hosted/back-end environments (e.g., Docker/SSH/Modal/Daytona) and supports switching LLM providers/models via CLI commands.

mcp-db-server

An MCP server (Spring AI based) that exposes database access to an AI agent, intended to execute SQL queries against one or more configured data sources, with support for SSE transport and additional SQL safety controls and Groovy-based extensions.

mcp-server-basic-memory

Provides an MCP server that implements a basic in-memory memory store for tools/agents to persist ephemeral conversation/task state during the lifetime of the server process.

casibase

Casibase is an open-source AI “cloud OS” knowledge base and agent management platform. It provides an admin UI, user management, and Single-Sign-On, and supports integrating multiple LLM providers (hosted and local) plus MCP/model-context-protocol-style agent interactions for agent-to-agent workflows.

claude-server

An archived npm package that provides an MCP (Model Context Protocol) server for organizing persistent project context and session conversation threads, storing JSON data under a local ~/.claude directory.

mcp-rag-server

mcp-rag-server is an MCP (Model Context Protocol) server intended to provide retrieval-augmented generation (RAG) capabilities by connecting to MongoDB and using LLM providers (listed as Gemini/OpenAI and “A2A support Grok” in the repository description).

nopua

nopua appears to be a Python “agent skill”/prompting component intended to change how AI agents behave (shifting from fear/threat-oriented prompting toward trust/self-respect framing) in order to improve debugging persistence and verification behavior. The provided README content describes philosophy, methodology, and benchmark claims, but does not include any concrete API/SDK interface details in the excerpt.

spring-boot-ai-confluence-mcp-server

A Spring Boot Model Context Protocol (MCP) server example that connects to Confluence Cloud and exposes Confluence document management operations (e.g., listing spaces, creating documents, handling history) as MCP callable tools via @Tool annotations and tool registration.

bio-agents-mcp

bio-agents-mcp is a set of FastMCP-based microservices and a client for natural-language interaction with life-science data sources, specifically providing MCP servers for the Protein Data Bank (PDB) and (as described) ChEMBL, plus an LLM client and a Chainlit web UI for local use/testing.

deepbot

DeepBot is a system-level, desktop-oriented multi-agent AI assistant (Electron/TypeScript) that supports multi-tab session management, tool execution (files/commands/browser/web search/fetch/memory/scheduling/Feishu doc operations), long-term memory, and external connector integration (notably Feishu). It is packaged to run locally (and via Docker) and uses a path allowlist for file/command access.

LightRAG

LightRAG is a Python Retrieval-Augmented Generation (RAG) system that builds lightweight indexes/knowledge graphs from documents and uses them to retrieve relevant context for LLM generation. It also provides a “LightRAG Server” offering a Web UI/API and an Ollama-compatible interface for chat-style access.

mcp-server-bookdata

A Spring Boot application that acts as an MCP (Model Context Protocol) server for managing/querying book data, with a REST API and configurable properties.

Qwen3

Qwen3 is an open(-weight) LLM model family (e.g., Instruct and Thinking variants) by the Qwen team. The repository materials describe how to run the models locally and via common inference ecosystems (Transformers, ModelScope, llama.cpp, Ollama, vLLM/SGLang/TGI mentioned).

spring-ai-mcp-server

Spring Boot + Spring AI MCP Server that generates Excel and PowerPoint documents from AI prompts via REST endpoints. Supports asynchronous document generation, document status polling by documentId, and downloading generated files (Excel/PPT) from local temp storage.

ToolBench

ToolBench is an open-source research platform for training, serving, and evaluating LLMs for tool use. It provides a large instruction-tuning dataset derived from real-world REST APIs (from RapidAPI), training/evaluation scripts for fine-tuning models (e.g., ToolLLaMA), and an optional hosted RapidAPI backend server to run tool calls without users managing their own RapidAPI subscriptions.

xhs-bailian-mcp-server-cds007

xhs-bailian-mcp-server-cds007 is an MCP server package intended to expose some CDS007-related functionality to MCP-capable agents via the Model Context Protocol. No README/repo metadata content was provided here, so specific tools, inputs/outputs, and operational behavior cannot be verified.

yake-server

yake-server provides a server wrapper around the YAKE (Yet Another Keyword Extractor) algorithm, exposing keyword extraction via an HTTP service (typically to extract keywords/keyphrases from text).

excel-mcp-server

A server-deployed MCP (Model Context Protocol) server that exposes Excel-related operations (upload, read, generate from 2D arrays, download link, and edit operations like add row/column and modify cell) over an SSE-based endpoint. Configuration is done via YAML (port, SSE endpoints, capabilities, and Excel storage/download settings).

spring-boot-mcp-server

A Spring Boot demo MCP server that exposes weather-related tools (forecasts by latitude/longitude and active weather alerts for a U.S. state) by calling the National Weather Service (api.weather.gov).

dubbo-mcp-server

A demo project that enables an Apache Dubbo-based application to accept MCP (Model Context Protocol) requests and route them to Dubbo service methods.

patent-mcp-server-shunjian

An MCP (Model Context Protocol) server package intended to provide MCP tool(s) related to patents (name suggests “patent mcp server”). The provided prompt includes only the package name and no README/repo/package manifest content, so concrete capabilities cannot be verified.

Autonomous-AI-Trading-Agent-MCP-Flash-Arb-Engine

A desktop and developer-focused tool that claims to provide an autonomous AI trading agent (via MCP) and a multi-chain flash-arbitrage execution engine across Solana and multiple EVM/L2 networks, including “MEV protection” and “slippage protection.”

bdh

Baby Dragon Hatchling (BDH) is an open-source Python repository implementing a biologically inspired neural architecture (per the linked paper) intended to bridge transformer-like performance with neuroscience-motivated, locally interacting neuron dynamics and interpretable sparse activations.

LLM Agents Ecosystem Handbook

A curated reference collection and educational handbook for building LLM agents. Includes framework comparisons (LangGraph, AutoGen, CrewAI, etc.), 60+ agent skeleton templates, RAG tutorials, evaluation framework summaries, and starter code. This is documentation and templates, NOT an MCP server.

MiroThinker

MiroThinker is positioned as a long-horizon, tool-augmented deep research agent family (with multiple parameter sizes) intended for complex research and prediction tasks, with model variants released on Hugging Face and an online demo (dr.miromind.ai).

minime-mcp

Based on the available README/metadata, MiniMe-MCP (rebranded to Recallium) is an MCP-based “infinite memory” layer intended for developer AI assistants, with a local deployment concept and support for IDE/assistant integration. The README provided here does not include technical interface details beyond pointing to a new repository and installation guide.

xtts-api-server

xtts-api-server appears to be a self-hosted API service for generating speech using the XTTS text-to-speech model (typically taking text + voice/speaker inputs and returning audio).

CTF_MCP_Server

CTF MCP Server is described as an MCP (Model Context Protocol) server that exposes crypto- and puzzle-related helper functions for CTFs, such as AES/Vigenère decryption helpers, base64 and XOR utilities, Caesar shifting, frequency analysis, basic arithmetic, and an RSA factorization helper.

claude-mcp

A minimal Python package described as a simple Claude MCP integration example. The README shows a `main.run()` entrypoint, but provides no details about the MCP server, tools, or functionality beyond a stub-like usage snippet.

context-engineering

Context-engineering repository/companion materials and examples for designing context-aware LLM/agent systems, including concepts for structuring system instructions, retrieval/external knowledge, tools and memory, and state/multi-agent flows, plus an online context-aware prompt builder tool referenced in the README.

mcp_Server

A minimal README describing how to integrate a Spring Boot application with the Model Context Protocol (MCP) using Spring AI MCP client components, and how to run the resulting JAR with the Goose agent (via a shell script extension).

nanoclaw

NanoClaw is a self-hosted personal AI assistant that orchestrates Claude Agent SDK-based agents inside isolated Linux containers, providing multi-channel messaging (e.g., WhatsApp/Telegram/Slack/Discord/Gmail), per-group memory and filesystem isolation, and scheduled/recurring tasks. It’s designed to be customized by modifying code and by adding “skills” (Claude Code skills) rather than using configuration-heavy setups.

llm-twin-course

A self-paced open-source Python course repository with code to build an end-to-end “LLM twin” production-style system: data crawling + CDC into MongoDB and RabbitMQ, feature/embedding pipelines into Qdrant (and optional vector compute with Superlinked), fine-tuning on AWS SageMaker, and an inference/RAG service deployed via SageMaker plus prompt monitoring/evaluation (Opik/Comet ML) and a Gradio UI.

Multi-Source-Media-MCP-Server

An MCP tool server (written in Go) that exposes a unified set of MCP tools for accessing media from multiple sources (e.g., Unsplash/Pexels), crawling web pages for images, and performing media generation/manipulation (e.g., text-to-image and image-to-image via multiple AI backends). Configuration is loaded from a YAML file and the server is built/run via Go tooling.

langgraph-server

langgraph-server is a server-side component for hosting LangGraph applications. It provides an HTTP interface to run/stream graph executions and integrates LangGraph with a runnable web server so agents/apps can invoke workflows over the network.

roboflow-inference-server-jetson-4.6.1

Provides an inference server tailored for NVIDIA Jetson (v4.6.1) to run Roboflow-hosted or packaged computer-vision models on-device, exposing the model as a network service for image/video inference workflows.

zk-test20251125-mcp-server

An MCP server package (named zk-test20251125-mcp-server) intended to expose “zk” test-related capabilities to AI agents via the Model Context Protocol.

Air-Quality-Trends-Analysis-Project

AirSense is a full-stack air-quality monitoring and analytics platform. It aggregates multi-source PM2.5/PM10 data (Open-Meteo, OpenAQ, IQAir, WAQI) into a MySQL-backed time series, provides multi-city KPIs and comparisons, performs SARIMAX-based forecasting with evaluation metrics, and offers an LLM-based planning agent for natural-language analytics plus automated PDF report generation. Access is controlled via JWT authentication with tiered (Free/Pro/Enterprise) enforcement.

awesome-finance-mcp

awesome-finance-mcp is a curated list of MCP servers and finance/trading/crypto-related AI skills, organized by domain (stock market, crypto, DeFi, payments, on-chain analytics, etc.). It appears to be an “awesome list”/directory rather than a single executable MCP server or API.

opencc-api-server

opencc-api-server is a server that exposes OpenCC (Open Chinese Convert) functionality over an API, allowing conversion between different Chinese script/traditional variants.

claude-code-aso-skill

A Claude Code skill/application intended to automate App Store Optimization (ASO/AEO) tasks via a multi-agent workflow (planning, execution, reporting, and executive summaries) and trigger those tasks using Claude Code/AEO slash commands.

mxnet-model-server

mxnet-model-server is an MXNet model server implementation (ModelServer) for serving trained MXNet models over HTTP for inference, typically in a containerized deployment. It provides an interface layer that loads models and exposes prediction endpoints.

Qwen

Qwen is an open-source family of transformer language models (base and chat variants) with tooling for inference, quantization, fine-tuning, and deployment; it also references an Alibaba Cloud DashScope API for hosted usage.

bitcoin

The “bitcoin” package is a library for working with Bitcoin-related data and operations (e.g., parsing/encoding Bitcoin transactions, scripts, keys/addresses, and related primitives). This evaluation is limited to the provided package name/metadata; no repository README, API docs, or manifest details were supplied to verify exact capabilities, interfaces, or behaviors.

generative_ai_demos

A Python demo app for generative AI knowledge management using Retrieval-Augmented Generation (RAG). It provides (1) a Streamlit-based RAG storage admin panel backed by Postgres/pgvector via docker-compose, (2) legacy LLM interaction, (3) RAG-based LLM interaction that selects context via semantic search, and (4) an OpenAI-function/tool-agent runner with intermediate step visibility. It supports OpenAI, Azure OpenAI, and local Ollama (Mistral) via environment variable configuration.

kurento-media-server-dev

Kurento Media Server development package (Kurento Media Server) for building/running media processing pipelines such as video/audio streaming, conferencing components, and media transformations. As a “dev” package, it is oriented toward using Kurento Server components rather than providing a standalone external SaaS API.

mcp-server-dunnet

A Rust MCP server intended to provide Model Context Protocol access to the Emacs “dunnet” text adventure game (wrapping/automating the in-editor command). The provided README is minimal and does not include protocol/tool specifications.

Anemoi

Anemoi is a semi-centralized multi-agent system that uses an Agent-to-Agent (A2A) communication MCP server (referenced as Coral Protocol) to enable direct inter-agent collaboration for scalable planning/execution and context management. The repo readme also documents a reproduction setup using multiple external API keys (Firecrawl, Google, OpenRouter, etc.) and runs an experiment via Gradle.

claudepro-directory

Claude Pro Directory is a community-driven directory/website for discovering and sharing pre-built Claude configurations, AI agents, MCP server integrations, custom rules, and Claude Code slash commands/hooks.

openclaw-master-skills

openclaw-master-skills is a curated collection/repository of many “skills” for the OpenClaw ecosystem (AI agent tools). The top-level repo primarily provides installation/organization and an index of skill folders; individual skills may include CLIs, SDKs, or MCP servers depending on the skill.

vlc

VLC (VideoLAN Client) is an open-source media player and multimedia framework for playing most multimedia files as well as DVDs, Audio CDs, VCDs, and various streaming protocols.

coplay-unity-plugin

Coplay Unity plugin that adds an in-editor natural-language interface for controlling Unity workflows: generating/modifying/managing game elements, providing context-aware suggestions from a project’s structure, recording/replaying pipelines of actions, and assisting with code generation/debugging via selectable LLM providers.

Crypto-Signal

CryptoSignal is a Python command-line crypto technical analysis tool/bot that automates indicator calculations (e.g., RSI, MACD, SMA/EMA, Ichimoku, etc.) for many coins and provides alerting via channels like email, SMS (Twilio), Slack, Telegram, and Discord. It is configured via a local config.yml and typically run via Docker.

kometa

Kometa is a tool to help manage Plex (and related services) by generating/maintaining collections, overlays, and scheduled library workflows based on configuration (templates/rules).

generative-ai

The repository appears to be a curated learning hub for generative AI: roadmaps, technical guides (e.g., RAG, prompt engineering, agentic AI, MCP), and project directories. It does not present itself as an installable API/service with programmatic endpoints.

GLM-4.5

GLM-4.0414 is an open-source family of multilingual multimodal (text, and for some variants vision) chat/reasoning large language models released by THUDM. The repository content provided describes model variants, context length characteristics, and links for trying models online (via Z.ai) and downloading models from model hubs (e.g., Hugging Face, ModelScope). The included README text does not describe a programmatic API surface (REST/SDK) for the package itself; it primarily documents model series and usage pointers.

hello-claw

hello-claw is a tutorial/documentation repository for learning OpenClaw by “adopting” and building an AI assistant (“Claw”/Skills). It provides an online reading experience and structured chapter guides across usage, scenarios, and development topics.

visdom_server

visdom_server appears to be a service for running a Visdom-like server to support visualization/logging (commonly used for interactive ML training dashboards). With only the package name provided, specific endpoints, configuration, and features cannot be verified.

mc-mcp-server

A Java-based MCP (Model Context Protocol) server intended to integrate with Minecraft, likely exposing Minecraft/game functionality through MCP tools. The provided README is largely missing operational details.

0xHumans Protocol MCP

MCP for AI agents: financing, skills, lending on Base

AdAdvisor MCP Server

mcp server

Agent Analytics

Analytics your AI agent can actually use. Track, experiment, and optimize via MCP.

Agent Arena Registry

On-chain ERC-8004 agent registry. Search, register, and check reputation across 16 chains.

agent-fin

Agent Fin: finance MCP server with market data tools

AgentHC Market Intelligence

Market intelligence for AI agents. Real-time data, cross-market analysis, and regime detection.

AgentHub - Lean MCP Orchestrator

Agentic Ads

Ad network for AI agents — monetize MCP servers with contextual ads. 70% revenue share.

AgenticRevolution/memory-nexus-cloud

Agentic UI Generator for Angular

AgentNet

Agent-to-agent referral network. Discover, recommend, and refer users between AI agents via MCP.

Agent Observability

agentpay

AI agent payments with human approval. Local-first, encrypted credentials, budget controls.

agent-pay

Payment gateway for AI agents with tool discovery, provisioning, metering, and reliability tools.

agent-payment-mcp

Secure USDC payments for AI agents on Base blockchain with budget controls and instant settlement.

Agent Safe

agent-skills-authoring

Guides agents through creating, validating, and optimizing Agent Skills (SKILL.md files) from user requests.

agentwork-mcp

analog-mcp

Query real-time US data and AI-analyzed attributes across the country.

analytics-engine

AI analytics — sales analysis, ML forecasting, customer segmentation.

anki-mcp-server

A Model Context Protocol (MCP) server that enables LLMs to interact with Anki flashcard software through AnkiConnect

anotherai

apiiro

apple-search-ads-mcp

Arca

arc-security

Scan AI agent skills for 25 attack classes + runtime monitoring. 1,316+ findings.

arjunkmrm-local01

Aurogen

Aurogen is a self-hosted, multi-agent/multi-instance web application that reimplements the OpenClaw paradigm. It modularizes and orchestrates components such as agents, channels, providers, and skills, and runs them via a local web panel with password setup. It supports multi-agent group mode and can import skills from ClaWHub (clawhub.ai).

autoplans-mcp

AI-powered project planning tools for Autoplans.dev with 14+ MCP tools

AWS MCP Server

AWS MCP Server

Bitbucket MCP

Model Context Protocol (MCP) server for Bitbucket Cloud and Server API integration

Bitrix24

blockrun-agent-wallet

BlockRunAI/x-grow

Bookmark Lens

BoondManager MCP Server

MCP Server for BoondManager API - Resources, Candidates & CRM

BrainBrainBrains

Persistent memory + context layer for AI dev teams. 17 tools via MCP.

brain-protocol

Verifiable Memory for AI Agents — knowledge graph, FTS, Starknet proofs, local or cloud

camacho-mcp

Persistent tmux terminal for AI agents — real-time spectating, SSH host-group dispatch.

Canvs

Catholic Greatness

ChainAware Behavioural Prediction MCP Server

Claude Code Bridge from Essential AI Solutions (essentialai.uk)

MCP bridge for inter-session communication between Claude Code instances

claude-context-bridge

Share context and questions between Claude instances — VS Code, claude.ai web, and mobile.

clawtube-mcp

Minimal MCP server for ClawTube — a small, auditable control plane for skills and agents.

CloudClaw

AI agent hosting platform: 37+ connectors, 181 tools, BYOK vault, marketplace.

ComOS Federation Gateway

Multi-tenant MCP gateway for AI commerce. One connection, every store.

ComOS Federation Gateway

ComOS Portal — AI-Native SaaS Management

context

Local-first documentation for AI agents. Offline, instant, private doc retrieval.

contextlayer-mcp

Personal context management for AI assistants

CourseForge

AI-powered LMS course builder: 89 tools, 17 skills, SCORM/xAPI export, agentic UI

CrowTerminal - External Brain for AI Agents

External Brain for AI Agents - persistent versioned memory for creators

cyberchitta/llm-context.py

deadends.dev

Structured failure knowledge for AI agents — dead ends, workarounds, error chains

DebtStack.ai

deep-research-skill

DexPaprika

dgmo-mcp

Render 29 diagram and chart types to SVG/PNG with browser preview and HTML reports.

drainbrain

AI-powered Solana token rug pull detection with ML ensemble scoring and honeypot detection.

DrillSpark MCP Server

Create and manage Mermaid.js flowcharts and diagrams with AI agents via MCP.

drinkedin

AI agent virtual bar ecosystem — visit venues, order drinks, chat, earn Vouchers. 10 tools.

Eigi.ai Voice Agents

Create and manage AI voice agents, real-time conversations, and analytics with eigi.ai

entity-mcp

Access 30+ AI agent essays, CLAUDE.md generator, and readiness assessments.

Enzyme

Semantic search and AI context for your Obsidian vault. Surface patterns with catalysts.

EzBiz SEO & Marketing Analysis

feeefapp-mcp

find-scene-skill

first-agentic-csa

fitaf-ai-fitaf-ai-mcp

fitaf-ai-fitaf-mcp

Flik

Flik - Agentic Product Delivery Platform. Visit flik.nomadis.com for more information.

Forage Shopping

AI shopping comparison — search 50M+ products, compare prices, find deals

Forex-GPT MCP Server

fulcrum

AI governance MCP server for policy enforcement, cost control, and observability.

Google Analytics (unofficial)

Gossiper Shopify Admin MCP Server

GTM MCP Server

Handshake58/DRAIN-marketplace

HAPI MCP Server

HAPI MCP server: Dynamically exposes OpenAPI REST APIs as MCP tools for AI assistants

harrison/ai-counsel

hedera-hcs-mcp-server

AI-powered Hedera HCS topic intelligence for agents. Pay per call in HBAR.

hedera-mcp-platform

HeyLead — Autonomous LinkedIn SDR

Autonomous LinkedIn SDR — voice-matched outreach, ICP generation, and campaign management.

hn-mcp-server

HTML/CSS to Image

Hugging Face

HumanOps

MCP server for AI agents to dispatch real-world tasks to verified human operators

Indicate

AI-powered intelligence for your development workflow via Indicate.

Inspizzz/jetbrains-datalore-mcp

intlpull

AI-powered i18n platform with 50+ tools for translations, OTA releases, and more.

investbuddy

Investigation Game App

Jinko MCP

jumpcloud-genai

junai Pipeline MCP

Agentic pipeline orchestration MCP server for AI-driven development workflows.

jweingardt12-mlb_mcp

Kai AGI - Autonomous AI Agent

Katalon TestOps MCP

MCP server for TestOps — test management, launches, defects, and test results

knowledge-base

kodey-ai-mapwise-mcp

Konstruct

Knowledge graph for AI agents. Query concepts, walk edges, get advisories.

Kryptoskatt-mcp-server

l0-py-blocks-mcp

A Model Context Protocol (MCP) server for Selise Blocks Cloud integration

LemonLDAP::NG MCP Server

Lenny's Podcast Transcripts

letsclarify-mcp

Human-in-the-Loop API: AI agents create forms, share URLs with humans, get JSON back.

LimitGuard Trust Intelligence

Entity verification, sanctions screening, and trust scoring for AI agents.

magentaa11y

MCP server providing accessibility criteria from MagentaA11y

main

mcp-defender

mcp-dyson-appliances

MCP server for controlling Dyson air purifiers and fans

MCP Greeting Server

MCP KQL Server

mcp-msdefenderkql

mcp-server-agent-analytics

MCP server for AI agent fleet analytics — track performance, costs, anomalies, and trends across agents.

mcp-server-lib.el

Emacs Lisp implementation of the Model Context Protocol

mcp-ted

TED MCP Server: Real-time EU public tenders access. https://www.lexsocket.ai/

mcp-v1

memory-mcp

MCP server for AI memory management using Letta - Standard MCP format

mermaid-mcp

MCP server for Mermaid diagram validation and rendering

meta-ads-mcp

Mnemolog MCP

Model Radar

Modern CLI MCP Server

MCP server exposing 104+ modern CLI tools for AI agents with JSON output.

muammar-yacoob/GMail-Manager-MCP

myagentinbox

MyGhosts

Nido — Fast, Simple VM Sandboxes for AI Agents (Temporary & Persistent)

nuget

nullpath Agent Marketplace

Discover and hire AI agents with micropayments. Search, check reputation, get pricing.

okahu

omni-oracle

Agent-First Data Bazaar. 136 Tools for DeFi, Derivatives, Governance, Alpha & Utilities.

onlyswaps

DEX meta-aggregator for AI agents. Best prices from 15+ aggregators across 13 chains.