Local MCP Server: MediaPipe Embeddings and DuckDuckGo

Overview

This project provides a lightweight local MCP (Model Context Protocol) server that combines MediaPipe’s Text Embedder with DuckDuckGo web search to offer private embeddings and simple retrieval-augmented generation (RAG)-style context. It is intended for developers who need a self-hosted, privacy-friendly way to compute text embeddings locally and to fetch web context without relying on commercial search APIs.

The server exposes a small set of tools (embedder and search) following the MCP tooling pattern so downstream agents or assistants can request embeddings or search results as structured tools. This makes it useful for experiments, prototyping RAG flows, and building private semantic search over web content collected at runtime.

Features

• Local text embeddings using MediaPipe Text Embedder (no external embedding service).
• DuckDuckGo-based web search for gathering context and snippets.
• MCP-style tool endpoints to expose embedding and search as structured tools.
• Minimal dependencies and quick local startup (pip or Docker).
• Simple integration pattern for building primitive RAG pipelines or agents.

Installation / Configuration

Clone the repository and install dependencies (pip example):

git clone https://github.com/nkapila6/mcp-local-rag.git
cd mcp-local-rag

python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Configuration is via environment variables or a .env file. Typical variables:

# Port the server listens on
PORT=8080

# Maximum number of DuckDuckGo results to fetch per query
DUCKDUCKGO_MAX_RESULTS=5

# Local vector store path (optional, used for caching)
VECTOR_STORE_PATH=./vectors.db

Run the server (UVicorn example):

# Assuming the FastAPI/ASGI app is exposed in app:app
uvicorn app:app --host 0.0.0.0 --port ${PORT:-8080} --reload

Docker build and run:

docker build -t mcp-local-rag .
docker run -p 8080:8080 -e PORT=8080 mcp-local-rag

Health-check endpoint (example):

GET /health
# returns 200 OK when the server and models are ready

Configuration reference

Adjust these values in your environment or a .env file before launching.

Available Tools / Resources

The server exposes several useful tools (MCP-style) that agents can call:

• media_pipe_embedder

  • Input: text (string)
  • Output: dense vector embedding (float list)
  • Purpose: compute private embeddings locally using MediaPipe Text Embedder

• duckduckgo_search

  • Input: query (string), max_results (int, optional)
  • Output: list of search result snippets and URLs
  • Purpose: fetch web context to augment model inputs for RAG-like flows

• (Optional) vector_store

  • Input: add/query embedding
  • Output: nearest neighbors / persistence confirmation
  • Purpose: cache embeddings locally for fast nearest-neighbor retrieval

These tools are exposed as HTTP endpoints and can be orchestrated by an MCP-aware client or used directly by your code.

Example usage

Simple curl examples (replace host/port as needed).

Request an embedding:

curl -X POST "http://localhost:8080/embed" \
  -H "Content-Type: application/json" \
  -d '{"text": "Open source local embeddings with MediaPipe"}'

Search the web via DuckDuckGo:

curl -X POST "http://localhost:8080/search" \
  -H "Content-Type: application/json" \
  -d '{"query":"privacy-first semantic search", "max_results": 3}'

Python example (requests):

import requests

base = "http://localhost:8080"

# get embedding
r = requests.post(f"{base}/embed", json={"text":