CaSee Intelligence MCP Server

Enterprise Competitive Intelligence Retrieval for AI Agents — Built on MCP (Model Context Protocol)

About CaSee — AI-Driven Competitive Intelligence Platform

CaSee is an AI-driven competitive intelligence & market insight platform — "Win by strategy, sense opportunities first, decide a thousand miles ahead".

CaSee delivers trusted-source competitive intelligence that helps startups find market opportunities and established enterprises expand their competitive advantages. It solves the core pain points of enterprise competitive intelligence:

• Fragmented intelligence collection

• Inefficient manual analysis

• Outdated market insights

• Intelligence that never reaches business decisions

Built for market, sales, product, and strategy teams of mid-to-large enterprises, CaSee connects market data with business decision-making — upgrading from passive competitive monitoring to proactive market trend prediction.

Platform Capabilities

Trusted Intelligence Assurance: Quantified T-Score credibility scoring, multi-source cross-validation, causal-reasoning bias detection, and compliance guardrails prevent AI agent hallucination, stale data, and false citations.

Try CaSee: https://casee.me — get your API key and explore the platform.

Related MCP server: BizIntel MCP Server

🎯 What is casee-mcp-server?

casee-mcp-server is the MCP (Model Context Protocol) gateway that exposes CaSee's competitive intelligence retrieval capabilities as standardized MCP Tools for AI Agents (WorkBuddy, Trae Work, Claude Desktop, LangChain, CrewAI, and any MCP-compatible framework).

It bridges two worlds:

• CaSee's trusted intelligence backend — 500+ trusted intelligence sources with T-Score credibility, real-time competitive dynamics, and quantified analysis

• Your AI Agent — any LLM application that speaks MCP (stdio or Streamable-HTTP)

With casee-mcp-server, your AI agents gain real-time, trusted-source intelligence retrieval from the CaSee platform — turning them from generic chat tools into verifiable competitive intelligence analysts that can search trusted sources, run complex logic retrieval, analyze trends, aggregate by source, and check statistics — all through 5 simple MCP tools.

🤖 Why casee-mcp-server?

LLM AI Agents (Claude, GPT, etc.) can generate competitive intelligence reports, but their analysis is limited by training data cutoff dates and unverifiable sources. When you ask an LLM directly about "global EV battery market trends," you get:

• Outdated information (trained months ago)

• Unverifiable sources (hallucinated or unknown provenance)

• Shallow analysis (lacks industry-specific frameworks)

casee-mcp-server bridges this gap by giving AI Agents access to real-time, trusted-source intelligence retrieval:

Core Value: Transforms AI Agents from "chat tools" into trusted competitive intelligence analysis systems — with timely, traceable, and quantifiable intelligence.

🚀 Quick Start

There are two ways to use casee-mcp-server:

Prerequisites

• Python 3.10+ (only required for Option A)

• A CaSee API Key (get one at https://casee.me) — required for both options; every intelligence request is authenticated with it

Option A — Build & Run Your Own MCP Server

Step 1: Get a CaSee API Key

Register at https://casee.me and create a read-only API key for your agent (we recommend scoping it to intelligence:read + sources:read). Keep it secret — it authenticates every request.

Step 2: Install

# From PyPI
pip install casee-mcp-server

# Or from source
git clone https://github.com/casee/casee-mcp-server.git
cd casee-mcp-server && pip install -e .

Step 3: Configure environment variables

export CASEE_API_KEY=casee_xxx                          # your CaSee API key (casee.me)
export CASEE_API_BASE_URL=https://casee.me # CaSee Intelligence Server URL

Step 4: Start the server

stdio mode — for Claude Desktop and local tools (a local process, one connection):

casee-mcp

Streamable-HTTP mode — for WorkBuddy / Trae Work / remote agents (exposes a single HTTP endpoint):

casee-mcp --http --port 8100

The server listens on http://127.0.0.1:8100/mcp by default. To expose it on the network, set MCP_HOST=0.0.0.0.

Step 5: Verify the server is alive

curl -X POST http://localhost:8100/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

You should receive an initialize result with serverInfo.name == "casee". Then list the tools:

# after initialize, get the session id from the response header "Mcp-Session-Id"
curl -X POST http://localhost:8100/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Mcp-Session-Id: <your-session-id>" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

You should see all 5 tools: find_trusted_sources, search_intelligence, analyze_trend, aggregate_by_source, get_intelligence_stats.

Step 6: Run with Docker (recommended for production)

# 1. configure your API key
echo "CASEE_API_KEY=casee_xxx" > .env

# 2. build & start
docker compose up -d

# 3. check status
docker compose ps

Option B — Connect to the Hosted MCP Server

No installation needed. The server is already deployed and running:

MCP endpoint : https://casee.me:8100/mcp
Transport    : Streamable-HTTP
Server       : casee (5 MCP tools)
Backend      : CaSee Intelligence Server (auto-resolved)

Just grab your CASEE_API_KEY from https://casee.me and plug the URL into your AI agent. Jump straight to Platform Integrations for the per-platform walkthrough — no Python, no Docker required.

Tip: For a quick sanity check before wiring a client, run the bundled test suite against the hosted endpoint:

python tests/test_mcp_server.py --url https://casee.me:8100/mcp

🧰 MCP Tools

The server exposes 5 MCP Tools for AI Agents:

Two-Stage Trusted Retrieval Workflow

┌────────────────────────────────────────────────────────────────┐
│  Stage 1: find_trusted_sources(category="wire", min_tscore=0.7) │
│  → Returns: [reuters, ap, bloomberg, ...]                       │
└──────────────────────────┬─────────────────────────────────────┘
                           │ source_ids
                           ▼
┌────────────────────────────────────────────────────────────────┐
│  Stage 2: search_intelligence(                                  │
│      q="+EV +(battery|charging) -China",                        │
│      source_ids=["reuters","ap","bloomberg"],                   │
│      min_tscore=0.6, days=30                                    │
│  )                                                              │
│  → Returns: verified, high-quality intelligence results         │
└────────────────────────────────────────────────────────────────┘

🔌 Platform Integrations

Below are step-by-step walkthroughs for wiring casee-mcp-server into each platform. Every example works with either:

• Option A — your self-hosted server (stdio or http://127.0.0.1:8100/mcp)

• Option B — the hosted endpoint https://casee.me:8100/mcp

Replace casee_xxx with your real key from https://casee.me, and replace https://casee.me:8100/mcp with your own URL if you self-host.

1. Claude Desktop

Claude Desktop launches MCP servers as local stdio processes, so it works best with Option A (or the url-based config below on newer versions).

Step 1: Install the server locally

pip install casee-mcp-server

Step 2: Open the Claude Desktop config file

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%\Claude\claude_desktop_config.json

If the file does not exist, create it.

Step 3: Add the casee-intelligence server

{
  "mcpServers": {
    "casee-intelligence": {
      "command": "casee-mcp",
      "env": {
        "CASEE_API_KEY": "casee_xxx",
        "CASEE_API_BASE_URL": "https://casee.me"
      }
    }
  }
}

Step 4: Restart Claude Desktop

Fully quit (Cmd+Q / Alt+F4) and relaunch Claude Desktop so it re-reads the config and spawns the server.

Step 5: Verify the tools

Click the tools (hammer) icon next to the composer input. You should see casee-intelligence with its 5 tools (find_trusted_sources, search_intelligence, analyze_trend, aggregate_by_source, get_intelligence_stats).

Step 6: Try it

Ask Claude:

"Use the casee tools to search for the latest Nvidia competitive intelligence from trusted sources, then summarize the key findings with their credibility scores."

Claude will call find_trusted_sources → search_intelligence and answer with traceable sources and tscore values.

Alternative — connect to the hosted endpoint (newer Claude Desktop versions):

{
  "mcpServers": {
    "casee-intelligence": {
      "url": "https://casee.me:8100/mcp",
      "headers": { "X-API-Key": "casee_xxx" }
    }
  }
}

2. WorkBuddy

WorkBuddy connects to MCP servers over Streamable-HTTP — ideal for the hosted endpoint (Option B) or your self-hosted server exposed on the network.

Step 1: Locate (or create) the WorkBuddy MCP config file

WorkBuddy registers MCP servers through the user-level config file:

.workbuddy/mcp.json

By convention, this file lives at the user's home directory (~/.workbuddy/mcp.json on macOS/Linux, %USERPROFILE%\.workbuddy\mcp.json on Windows). If it does not exist, create it.

Step 2: Add the casee-intelligence server

Edit .workbuddy/mcp.json and add an entry under mcpServers:

{
  "mcpServers": {
    "casee-intelligence": {
      "transport": "streamable-http",
      "url": "https://casee.me:8100/mcp",
      "headers": {
        "X-API-Key": "casee_xxx"
      }
    }
  }
}

Field reference:

Note: The X-API-Key header is what WorkBuddy will forward on every MCP request so the upstream casee-mcp-server can authenticate against the CaSee Intelligence backend. If you also need to override the backend URL, set it as an environment variable on the server side (e.g. in the Docker container's env), not in this client config.

Step 3: Save the file and reload WorkBuddy

Save .workbuddy/mcp.json, then trigger a config reload in WorkBuddy (typically Cmd/Ctrl+R in the MCP panel, or restart the WorkBuddy desktop app).

Step 4: Verify the tools

Open the MCP tool panel. You should see casee-intelligence with its 5 tools (find_trusted_sources, search_intelligence, analyze_trend, aggregate_by_source, get_intelligence_stats).

Step 5: Try it

Ask WorkBuddy:

"Track the latest EV battery competition signals across trusted sources."

WorkBuddy will call find_trusted_sources → search_intelligence and answer with traceable sources and tscore values.

Self-hosted variant — if you run your own MCP server on the same machine, point url to http://127.0.0.1:8100/mcp instead. The rest of the file stays identical.

{
  "mcpServers": {
    "casee-intelligence": {
      "transport": "streamable-http",
      "url": "http://127.0.0.1:8100/mcp",
      "headers": {
        "X-API-Key": "casee_xxx"
      }
    }
  }
}

3. Trae Work

Trae Work registers MCP servers through the global config file ~/.trae-cn/mcp_servers.json and connects over Streamable-HTTP.

Step 1: Locate the MCP config file

~/.trae-cn/mcp_servers.json

If it does not exist, create it.

Step 2: Add the casee-intelligence entry

{
  "mcpServers": {
    "casee-intelligence": {
      "transport": "streamable-http",
      "url": "https://casee.me:8100/mcp"
    }
  }
}

For self-hosted: point url to http://127.0.0.1:8100/mcp instead.

Step 3: Reload / restart Trae Work

Reload the MCP configuration (or restart Trae Work) so it picks up the new server.

Step 4: Verify the tools

Open the MCP tool panel. You should see casee-intelligence with 5 tools. Enable the ones you need.

Step 5: Ask for intelligence

Example prompt:

"Use casee search to find recent AI regulation developments, filter by trusted sources only, and summarize the trend over the last 30 days."

4. LangChain Integration

LangChain agents consume MCP tools through the official mcp Python client. The example below wraps casee-mcp into a LangChain BaseTool (stdio mode — Option A).

Step 1: Install dependencies

pip install casee-mcp-server mcp langchain

Step 2: Define the tool

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI
from langchain.tools import BaseTool

class CaseeSearchTool(BaseTool):
    name = "casee_search"
    description = "Search competitive intelligence with query syntax: +AND, -NOT, |synonyms"

    def _run(self, query: str) -> str:
        import asyncio
        return asyncio.run(self._arun(query))

    async def _arun(self, query: str) -> str:
        async with stdio_client(
            StdioServerParameters(
                command="casee-mcp",
                env={"CASEE_API_KEY": "casee_xxx"}
            )
        ) as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                result = await session.call_tool("search_intelligence",
                    arguments={"q": query, "days": 30})
                return result.content[0].text

llm = OpenAI(temperature=0)
agent = initialize_agent(
    tools=[CaseeSearchTool()], llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)
agent.run("Find EV battery competition intelligence from trusted sources")

Step 3: Run the agent

The agent now decides when to call casee_search during its reasoning loop, giving your LLM real-time, trusted-source data instead of stale training knowledge.

Connecting to the hosted endpoint — use StreamableHttpClient against https://casee.me:8100/mcp instead of stdio_client:

from mcp.client.streamable_http import streamable_http_client
from mcp import ClientSession

async def call_hosted(query: str) -> str:
    async with streamable_http_client(
        url="https://casee.me:8100/mcp",
        headers={"X-API-Key": "casee_xxx"},
    ) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool(
                "search_intelligence", arguments={"q": query, "days": 30})
            return result.content[0].text

5. CrewAI Integration

CrewAI agents use LangChain-style tools. Wrap the MCP call in a @tool-decorated function so your Crew agents can retrieve intelligence during their tasks (stdio mode — Option A).

Step 1: Install dependencies

pip install casee-mcp-server mcp langchain crewai

Step 2: Define the tool & Crew

from crewai import Agent, Task, Crew, Process
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain.tools import tool

@tool
async def search_intel(q: str) -> str:
    """Search competitive intelligence. q: query syntax like +EV +(battery|charging)"""
    async with stdio_client(
        StdioServerParameters(command="casee-mcp", env={"CASEE_API_KEY": "casee_xxx"})
    ) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            result = await session.call_tool("search_intelligence",
                arguments={"q": q, "days": 30})
            return result.content[0].text

analyst = Agent(
    role="Competitive Intelligence Analyst",
    goal="Retrieve and analyze market intelligence from trusted sources",
    tools=[search_intel],
)

task = Task(
    description="Search for EV battery technology intelligence and summarize key findings",
    agent=analyst,
)

crew = Crew(agents=[analyst], tasks=[task], process=Process.sequential)
result = crew.kickoff()

Step 3: Run the crew

crew.kickoff() runs the analyst agent, which calls search_intel to pull real-time intelligence into its analysis.

Connecting to the hosted endpoint — swap stdio_client for streamable_http_client(url="https://casee.me:8100/mcp", headers={"X-API-Key": "casee_xxx"}) exactly as shown in the LangChain section above.

🐳 Docker Deployment

# Clone and build
git clone https://github.com/casee/casee-mcp-server.git
cd casee-mcp-server

# Set your API key
echo "CASEE_API_KEY=casee_xxx" > .env

# Start
docker compose up -d

# Check health
docker compose ps
curl -X POST http://localhost:8100/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

⚙️ Configuration

📊 Architecture

┌──────────────────────────────────────────────────────────────────┐
│                     AI Agent Platform Layer                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────────┐  ┌────────────┐   │
│  │WorkBuddy │  │ Trae Work│  │Claude Desktop│  │LangChain   │   │
│  └────┬─────┘  └────┬─────┘  └──────┬───────┘  └─────┬──────┘   │
└───────┼──────────────┼──────────────┼───────────────┼───────────┘
        │              │              │               │
        │     MCP Protocol (stdio / Streamable-HTTP)   │
        │              │              │               │
┌───────┴──────────────┴──────────────┴───────────────┴───────────┐
│                    casee-mcp-server (this project)                 │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │  Tools: find_trusted_sources / search_intelligence /     │   │
│  │         analyze_trend / aggregate_by_source / stats      │   │
│  └──────────────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │  casee SDK (search_sources / search_advanced / ...)       │   │
│  └──────────────────────────────────────────────────────────┘   │
└───────────────────────────┬─────────────────────────────────────┘
                            │  HTTP (X-API-Key)
┌───────────────────────────┴─────────────────────────────────────┐
│  CaSee Intelligence Server (is_server)                            │
│  /v1/sources/search  │  /v1/searchx  │  /v1/search  │  ...      │
└─────────────────────────────────────────────────────────────────┘

🎯 Use Cases — Competitive Intelligence in Action

This chapter walks through a complete, end-to-end competitive intelligence workflow, applied through casee-mcp-server's 5 MCP tools. Every step is given both as a direct API call and as the equivalent MCP Tool invocation your AI agent will use.

Scenario — Global EV Market Intelligence

A market intelligence team at an automotive OEM needs to track the global New Energy Vehicle (NEV / EV) market in real time:

Step 1 — Define the Intelligence Requirement

Translate the business requirement into a structured query:

In Google-style query syntax (the q parameter of search_intelligence):

+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|"electric vehicle"|battery|charging) +(China|Europe|US) -rumor

Step 2 — Find Trusted Sources

Direct API:

curl -H "X-API-Key: $CASEE_API_KEY" \
  "https://casee.me/v1/sources/search?category=wire&min_tscore=0.6&sample_size=2"

Via MCP (call from your agent):

Tool: find_trusted_sources
Arguments:
  category  = "wire"
  min_tscore = 0.6
  sample_size = 2
  limit     = 20

Response (excerpt):

{
  "count": 3, "total": 3,
  "sources": [
    {
      "source_id": "reuters-business",
      "name": "Reuters Business",
      "category": "wire",
      "tier": 1,
      "propaganda_risk": "low",
      "state_affiliated": false,
      "tscore": 0.81,
      "sample_data": [
        { "title": "EU tariffs on Chinese EV imports ...", "tscore": 0.81 }
      ]
    }
  ]
}

Capture the source_id list (e.g. ["reuters-business", "ap-news", "ansa"]) — they become the source_ids argument in Step 3.

Step 3 — Two-Stage Intelligence Retrieval

Use the trusted source_ids from Step 2 with the query from Step 1.

Direct API:

curl -G -H "X-API-Key: $CASEE_API_KEY" \
  "https://casee.me/v1/searchx" \
  --data-urlencode 'q=+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|battery|charging) +(China|Europe|US) -rumor' \
  --data-urlencode 'source_ids=reuters-business,ap-news,ansa' \
  --data-urlencode 'min_tscore=0.6' \
  --data-urlencode 'days=30' \
  --data-urlencode 'limit=50'

Via MCP (call from your agent):

Tool: search_intelligence
Arguments:
  q          = '+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|battery|charging) +(China|Europe|US) -rumor'
  source_ids = ["reuters-business", "ap-news", "ansa"]
  min_tscore = 0.6
  days       = 30
  limit      = 50

The result is a list of verified, high-credibility intelligence items — each with title, source_id, published_at, tscore, and url for full traceability.

Step 4 — Analyze & Visualize the Intelligence

Once you have the trusted items, the agent (or a downstream BI tool) performs four standard analyses. Each is also available as a one-shot MCP Tool call:

Example MCP conversation (the agent calls them in sequence):

User: "Give me an EV market briefing for the last 30 days, only top sources."

Agent:
  → find_trusted_sources(category="wire", min_tscore=0.7, limit=20)
  → search_intelligence(q='+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|battery|charging) +(China|Europe|US)',
                        source_ids=[...], min_tscore=0.6, days=30)
  → analyze_trend(q='+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|battery|charging) +(China|Europe|US)',
                  source_ids=[...], days=30)
  → aggregate_by_source(q='+(Tesla|BYD|NIO|Xpeng|Volkswagen) +(EV|battery|charging) +(China|Europe|US)',
                        source_ids=[...], days=30)
  → Summarize: vendor-by-vendor movement, regional split, week-over-week change,
              and call out any items with tscore ≥ 0.8 as 'high-credibility signals'.

This is the two-stage trusted retrieval pattern (see MCP Tools): discover sources first, then search with the discovered sources — turning a noisy LLM answer into a traceable, quantified competitive intelligence brief.

Other Reference Use Cases

The same pattern works for any vertical. Three additional scenarios documented at api-docs:

For all three, the agent applies the same four-step pattern: define query → find_trusted_sources → search_intelligence → analyze / aggregate / trend → summarize.

Business Value of This Workflow

📄 License

MIT © CaSee

🔗 Links

• API Key: https://casee.me

• API Documentation: https://casee.me/api-docs

• CaSee SDK: https://casee.me/sdk/

• MCP Protocol: https://modelcontextprotocol.io