Squad AI MCP Server for Product Discovery

Overview

The Squad AI MCP Server for Product Discovery is a lightweight back-end that stores and manages structured product discovery artifacts (opportunities, outcomes, requirements, feedback) and exposes them to any MCP-aware language model or client. It implements the Model Context Protocol (MCP) patterns so an LLM can create, query, and update discovery data as part of interactive workflows—making it easier to combine human and model intelligence during ideation, research synthesis, and planning.

Designed for developer teams and AI integrations, the server acts as a canonical store and a set of “tools” that LLMs or apps can call. That makes it simple to persist model-produced artifacts, retrieve contextual history for follow-ups, and keep discovery artifacts synchronized with human edits or product systems.

Features

• Persistent models for product discovery: opportunities, outcomes, requirements, feedback
• MCP-aware tool surface so LLMs can call create/query/update actions
• Simple HTTP API compatible with MCP tool invocation patterns
• Query and filtering support for retrieving related artifacts
• Configuration for local development and containerized deployment
• Example payloads and cURL snippets to get you started

Installation / Configuration

Prerequisites:

• Node.js 18+ (or the runtime indicated in the repo)
• Docker (optional for containerized deployment)

Clone and run locally:

git clone https://github.com/the-basilisk-ai/squad-mcp.git
cd squad-mcp
npm install
npm run dev

Environment variables (example .env):

PORT=3000
DATABASE_URL=postgres://user:pass@localhost:5432/squad
JWT_SECRET=replace-with-a-secure-secret
MCP_BASE_PATH=/mcp

Run with Docker:

# build image
docker build -t squad-mcp .

# run container (example)
docker run -p 3000:3000 \
  -e PORT=3000 \
  -e DATABASE_URL=postgres://user:pass@db:5432/squad \
  -e JWT_SECRET=secret \
  squad-mcp

If the repository includes an example Docker Compose file, use it to bring up the server and database together:

docker-compose up

Available Tools / Resources

The server exposes a small set of resources and corresponding HTTP endpoints that align with MCP tool semantics. Typical resource types:

• opportunity — a candidate product idea or market hypothesis
• outcome — measurable goals or success criteria tied to an opportunity
• requirement — functional or non-functional requirements derived from outcomes
• feedback — raw or synthesized user feedback linked to an opportunity or requirement

Common endpoints (examples):

MCP tool invocation pattern (example) Clients or LLM runners that support MCP can call “tools” using structured JSON. Example (illustrative):

{
  "tool": "squad.create_opportunity",
  "input": {
    "title": "Reduce onboarding time for new users",
    "description": "Users take too long to reach 'Aha' — investigate onboarding flow",
    "tags": ["onboarding", "conversion"],
    "source": "llm:session-123"
  }
}

The server will return a canonical object with id, timestamps, and links to related artifacts.

Use Cases

1. LLM-assisted discovery sessions

   • An MCP-aware LLM generates a set of candidate opportunities during a brainstorming session. Each candidate is sent to the MCP server via the create_opportunity tool, producing persistent records that product teams can review and prioritize.

2. Feedback synthesis and traceability

   • After running user interviews, an LLM summarizes feedback and creates feedback items linked to related opportunities or requirements. The server stores these links so downstream queries can surface the original feedback behind decisions.

3. Outcome-driven planning

   • Product strategists use the server to record outcomes for a given opportunity. Requirements are then generated (or validated) by an LLM and attached to those outcomes, creating a traceable chain from idea to measurable goal to implementation needs.

4. Automated context for agents

   • When an LLM agent receives a request to propose next steps, it queries the MCP server for related outcomes and feedback to ground its recommendations in stored context rather than beginning from scratch.

Examples

Create an opportunity via cURL:

curl -X POST http://localhost:3000/api/opportunities \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Improve first-run activation",
    "description": "Users fail to complete initial setup within 10 minutes",
    "tags": ["activation","ux"]
  }'

Query opportunities with filters:

curl "http://localhost:3000/api/opportunities?tag=activation&status=open"

Patch an outcome:

curl -X PATCH http://localhost:3000/api/outcomes/abcd-1234 \
  -H "Content-Type: application/json" \
  -d '{"targetMetric": {"name":"activation_rate","value":0.25}}'

Next steps

• Inspect the repository for schema definitions and example clients (look in /examples or /docs if present).
• Integrate an MCP-capable LLM runner (tool-calling frameworks or SDKs) and map tool names to server endpoints.
• Add authentication and RBAC as needed for your deployment, and back up the database regularly.

This server provides a practical foundation for integrating LLM workflows into product discovery pipelines by centralizing artifacts and exposing them through an MCP-friendly API.