Dappier MCP Server: Real-Time News, Sports, Finance, Crypto

Overview

Dappier MCP Server (Model Context Protocol server) provides a standardized, low-latency way to enrich large language model (LLM) inputs with real‑time, rights‑cleared content. The server aggregates and indexes content across news, sports, finance, crypto, and premium publishers, then exposes that content through simple HTTP endpoints that LLMs or orchestration services can call to fetch contextual data before or during prompt construction.

This separation of concerns—context retrieval from generation—lets you build LLM applications that remain accurate and up‑to‑date without overloading the model with the responsibility of live data ingestion. Use it to add breaking news, live scores, market prices, or licensed articles into prompts in a structured, auditable way.

Features

• Aggregates real‑time, rights‑cleared content across news, sports, finance, crypto, and premium publishers
• Standardized MCP-compatible HTTP endpoints for context retrieval
• Fast queries with configurable relevance and time windows
• Built-in caching and configurable TTLs
• Filtering and metadata (source, timestamp, license) returned with results
• Docker and Docker Compose friendly for local and production deployment
• Simple JSON API suitable for serverless functions, agent frameworks, and LLM chain integrations

Installation / Configuration

Clone the repository and run with Docker or Docker Compose. The examples below are minimal—adjust env vars for your environment and provider credentials.

Clone the repo:

git clone https://github.com/DappierAI/dappier-mcp.git
cd dappier-mcp

Build and run with Docker:

docker build -t dappier-mcp .
docker run -p 8080:8080 \
  -e DAPPIER_API_KEY=your_api_key \
  -e REDIS_URL=redis://redis:6379 \
  -e PORT=8080 \
  dappier-mcp

Example docker-compose.yml:

version: "3.8"
services:
  dappier-mcp:
    image: dappier-mcp:latest
    build: .
    ports:
      - "8080:8080"
    environment:
      - DAPPIER_API_KEY=${DAPPIER_API_KEY}
      - REDIS_URL=redis://redis:6379/0
      - PORT=8080
  redis:
    image: redis:7
    restart: unless-stopped

Common environment variables:

The server accepts a configuration file (config.yaml) to control sources, licensing filters, and TTLs. Example config snippet:

sources:
  news:
    enabled: true
    api_key: ${SOURCE_NEWS_KEY}
  finance:
    enabled: true
    providers:
      - name: market-data
        api_key: ${SOURCE_MARKET_KEY}
cache:
  ttl_seconds: 300

Available Resources

The MCP server exposes a small set of HTTP endpoints designed for fast, programmatic usage. Typical endpoints include:

• GET /health — service health
• POST /mcp/context — query for contextual documents (body: { query, filters, size })
• GET /mcp/sources — list available content sources and metadata
• POST /mcp/search — keyword/semantic search across indexed content

Returned results include fields like: id, title, snippet, source, timestamp, license, and relevance_score. Each document payload includes enough metadata to let you show provenance in UIs or include licensing decisions in downstream flows.

Use Cases

1. Real‑time news summarization

   • Flow: Fetch latest articles for a company ticker → prepend context to prompt → generate an earnings summary or Q&A.
   • Example: POST /mcp/context { “query”: “Apple earnings”, “filters”: { “last_hours”: 24 }, “size”: 5 }

2. Financial assistant with live quotes

   • Flow: Query finance/crypto sources for current prices and recent headlines → return a short market brief to users or trading agents.
   • Example: Request top 3 documents for BTC and current price feed (combined in prompt).

3. Sports commentary and score updates

   • Flow: Retrieve latest game summary and play-by-play snippets → embed into a commentary generation prompt for dynamic match reports.

4. Rights‑compliant use of premium publisher content

   • Flow: Use the server to discover licensed articles, include publisher metadata and license terms to ensure compliant display and summarization.

Concrete JavaScript example (fetch context, then call an LLM):

// Fetch contextual docs from MCP server
const ctxResp = await fetch('http://localhost:8080/mcp/context', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer YOUR_KEY' },
  body: JSON.stringify({ query: 'Tesla earnings', size: 5, filters: { last_hours: 48 } })
});
const docs = await ctxResp.json();

// Construct prompt for an LLM
const contextText = docs.map(d => `- ${d.title} (${d.source}, ${d.timestamp}): ${d.snippet}`).join('\n');
const prompt = `Context:\n${contextText}\n\nTask: Summarize the key points relevant to Tesla's latest earnings.`;

// Send to LLM (example pseudocode)
const llmResp = await fetch('https://api.openai.com/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${OPENAI_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ model: 'gpt-4o', messages: [{ role: 'user', content: prompt }] })
});

Next Steps and Links

• Explore the repository for deployment examples and configuration templates.
• Review source metadata and licensing fields to ensure your application meets display and rights requirements.
• Integrate the MCP server into your LLM orchestration layer (agents, retrieval-augmented generation pipelines, or prompt templates) to provide