Overview

The Context Processor MCP (Model Context Protocol) Server is a small, configurable service for extracting and enriching metadata from textual content and associated resources. It implements a pipeline-oriented approach to context processing with four primary modes—clarify, analyze, search, and fetch—so you can tailor how content is transformed and prepared for downstream systems such as search indexes, QA chains, or knowledge graphs.

This server is useful when you need automated, repeatable preprocessing of documents and content fragments: clarifying ambiguous references, analyzing structure and entities, performing targeted search for related context, and fetching external resources referenced in the content. By separating these concerns into modular processors, the MCP server helps improve relevance and discoverability in search and retrieval applications.

Repository: https://github.com/mschultheiss83/context-processor

Features

Configurable pipeline with four built-in modes: clarify, analyze, search, fetch
Modular processors that can be composed per-request or by configuration
Pluggable connectors for search and resource fetching
Structured metadata output (entities, summaries, citations, search hits)
HTTP API for synchronous processing and JSON payloads
Lightweight, suitable for integration into ingestion and indexing workflows

Installation / Configuration

Basic setup (clone and run):

# clone the repository
git clone https://github.com/mschultheiss83/context-processor.git
cd context-processor

# install dependencies (if Node-based)
npm install

# start in development mode
npm run dev

Docker (example):

# build the image
docker build -t context-processor .

# run with default config
docker run -p 8080:8080 context-processor

Example configuration (JSON/YAML) — this defines the pipeline and connectors:

{
  "server": {
    "port": 8080,
    "logLevel": "info"
  },
  "pipeline": [
    {
      "name": "clarify",
      "type": "clarifier",
      "params": {
        "maxQuestions": 3,
        "language": "en"
      }
    },
    {
      "name": "analyze",
      "type": "analyzer",
      "params": {
        "extractEntities": true,
        "extractTopics": true,
        "sentiment": false
      }
    },
    {
      "name": "search",
      "type": "searcher",
      "params": {
        "connector": "elastic",
        "index": "documents",
        "topK": 5
      }
    },
    {
      "name": "fetch",
      "type": "fetcher",
      "params": {
        "followRedirects": true,
        "maxBytes": 1000000
      }
    }
  ],
  "connectors": {
    "elastic": {
      "type": "elasticsearch",
      "url": "http://elasticsearch:9200",
      "apiKey": "..."
    }
  }
}

API example: process content via HTTP POST

curl -X POST http://localhost:8080/process \
  -H "Content-Type: application/json" \
  -d '{
    "mode": ["clarify", "analyze", "search"],
    "content": "Can you summarize the release notes for product X and find related docs?",
    "metadata": { "source": "upload-2026-04-01" }
  }'

Available Tools / Resources

The MCP server exposes a set of tools (processors) you can enable or extend. Typical built-ins:

Clarifier: prompts or heuristics to disambiguate vague phrases, expand acronyms, or generate follow-up clarification queries.
Analyzer: NLP routines to extract entities, topics, summaries, and structural metadata.
Searcher: connector layer to query external indexes (Elasticsearch, OpenSearch, vector DBs) and return top hits with relevance scores.
Fetcher: HTTP/URL fetcher to crawl and retrieve referenced documents, images, or attachments for inline analysis.

You can add custom processors by implementing the processor interface (input, params, output) and registering it in the configuration.

Use Cases

Search indexing pipeline
- Ingest documents through the MCP server with analyze + search modes to extract entities and find related documents. Store resulting metadata (entities, summary, related_ids) alongside indexed content to improve query relevance and suggestion features.
Customer support knowledge enrichment
- Run Clarify then Fetch on incoming tickets to expand ambiguous terms and retrieve linked KB articles. The Analyzer can then extract actionable entities (product names, versions) for automated routing or suggested responses.
Contextual QA and LLM prompting
- Use Search to fetch the most relevant passages from a document corpus, then run Clarify to produce precise prompts or follow-up questions for an LLM. This reduces hallucination by grounding prompts in extracted metadata and citations.
Content migration and cleanup
- For large content migrations, run Analyze to detect deprecated terminology and summarize pages. Combine Fetch to pull external references and produce a mapping of broken links, citations, and recommended replacements.

Data model and outputs

Typical output JSON (shortened):

{
  "inputId": "req-123",
  "results": {
    "clarify": { "questions": ["Do you mean product X v2 or X Suite?"] },
    "analyze": { "summary": "Release notes for Product X v2...", "entities": ["Product X", "v2"] },
    "search": { "hits": [{"id":"doc-7","score":0.92}] },
    "fetch": { "resources": [{"url":"https://example.com/doc.pdf","status":200}] }
  },
  "elapsedMs": 312
}

This structured output makes it straightforward to persist metadata, feed downstream services, or generate UI-level contextual hints.

Next steps

Review the repository README and examples in the GitHub project: https://github.com/mschultheiss83/context-processor
Start with a minimal pipeline (analyze only) and progressively enable other processors
Implement connectors for your search/index backend and register them in the config

This MCP server is designed to be adaptable—compose the clarify, analyze, search, and fetch tools to match the needs of search, retrieval, and metadata extraction workflows.

Context Processor MCP Server for Metadata Extraction