concierge MCP — Use Cases, Install & Live Demo

Why use it

Key features

Progressive disclosure — only expose tools relevant to the current workflow step
Workflow state shared across steps without manual plumbing
Semantic tool search — worth it once you cross ~100 tools
Multiple transports: stdio, HTTP, SSE
Session-isolated — concurrent workflows don't clobber each other

Live Demo

What it looks like in practice

concierge.replay ▶ ready

0/0

Install

Pick your client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "concierge": {
      "command": "uvx",
      "args": [
        "concierge"
      ],
      "_inferred": true
    }
  }
}

Open Claude Desktop → Settings → Developer → Edit Config. Restart after saving.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "concierge": {
      "command": "uvx",
      "args": [
        "concierge"
      ],
      "_inferred": true
    }
  }
}

Cursor uses the same mcpServers schema as Claude Desktop. Project config wins over global.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "concierge": {
      "command": "uvx",
      "args": [
        "concierge"
      ],
      "_inferred": true
    }
  }
}

Click the MCP Servers icon in the Cline sidebar, then "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "concierge": {
      "command": "uvx",
      "args": [
        "concierge"
      ],
      "_inferred": true
    }
  }
}

Same shape as Claude Desktop. Restart Windsurf to pick up changes.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "concierge",
      "command": "uvx",
      "args": [
        "concierge"
      ]
    }
  ]
}

Continue uses an array of server objects rather than a map.

~/.config/zed/settings.json

{
  "context_servers": {
    "concierge": {
      "command": {
        "path": "uvx",
        "args": [
          "concierge"
        ]
      }
    }
  }
}

Add to context_servers. Zed hot-reloads on save.

claude mcp add concierge -- uvx concierge

One-liner. Verify with claude mcp list. Remove with claude mcp remove.

Use Cases

Real-world ways to use concierge

Wrap a giant REST API (200+ endpoints) as an MCP without blowing the context

👤 Platform engineers exposing internal APIs to LLMs ⏱ ~90 min advanced

When to use: Your company's API has 300 endpoints and a naive MCP dumps all of them into the system prompt, wrecking latency and hit rate.

Prerequisites

Python 3.9+ — pyenv / uv
OpenAPI spec or endpoint catalog — Your API gateway / Swagger

Flow

Scaffold with concierge-sdk

Using concierge-sdk, scaffold an MCP server that wraps my OpenAPI spec at ./openapi.yaml. Make it use semantic search rather than listing all tools up front.✓ Copied

→ Boilerplate code + search handler
Define workflow stages

Group the endpoints into 3 workflows: 'read operations', 'create operations', 'admin'. Each workflow exposes only its own tools.✓ Copied

→ Workflow definitions with tool allowlists
Test with Claude

Connect Claude Desktop to this server and verify that listing tools only shows the search tool + current workflow tools — not all 300.✓ Copied

→ Claude sees ~10 tools, not 300

Outcome: A large API surface usable by an LLM without collapsing on system prompt length.

Pitfalls

Semantic search returns the wrong tool when descriptions are too similar — Write distinctive one-line tool descriptions; test search with held-out queries

Build a guided multi-step workflow (e.g. customer onboarding)

👤 Devs building structured agent flows ⏱ ~60 min advanced

When to use: You want the LLM to follow a defined sequence: collect info → validate → create record → notify. Each step has its own tools.

Flow

Declare the workflow

Define a concierge workflow 'customer_onboarding' with steps [collect, validate, create, notify], each with its own tool set.✓ Copied

→ Workflow config
Share state

Pass the customer_data dict from step 1 into steps 2, 3, 4 via shared state. Show me how.✓ Copied

→ State-object code
Handle failure

If validate fails, return to step 1 with the specific fix needed.✓ Copied

→ Retry/backtrack logic

Outcome: A robust guided flow that keeps the LLM on-rails.

Pitfalls

LLM tries to skip steps — Concierge enforces order at the tool-visibility level — skipping is physically impossible if you wired it right

Ship your first MCP server in 15 minutes

👤 Developers new to MCP ⏱ ~15 min beginner

When to use: You want to expose 3-5 functions to Claude and don't want to learn the raw MCP spec.

Flow

Install and scaffold

pip install concierge-sdk. Generate a minimal server exposing two tools: add(a, b) and greet(name). Stdio transport.✓ Copied

→ Working Python file
Run and connect

Add to Claude Desktop config and test that both tools are callable.✓ Copied

→ Tool calls succeed in Claude

Outcome: A working MCP server you wrote end-to-end in an afternoon.

Pitfalls

Missing type hints — SDK relies on them for tool schema — Always type your args and return — concierge generates the MCP schema from them

Combinations

Pair with other MCPs for X10 leverage

concierge + gateway

Serve concierge-built MCP behind a security gateway for PII redaction

Start concierge server on :8001, then add it as an upstream to mcp-gateway with Presidio plugin.✓ Copied

Tools

What this MCP exposes

Tool	Inputs	When to call	Cost
concierge.workflow(name)	name, steps, initial_state	Define a named multi-step flow	framework only
concierge.tool(workflow, step)	step allowlist	Attach a function as a tool scoped to one or more steps	framework only
concierge.search_tools	query: str	Auto-exposed when you have too many tools to list eagerly	free
concierge.serve()	transport: 'stdio'\|'http'\|'sse'	Entry point of your script	free

Cost & Limits

What this costs to run

API quota: None — you're the author
Tokens per call: Depends on your tool design; progressive disclosure shrinks system prompts 5-10x
Monetary: Free and open source
Tip: Don't eagerly expose every tool. Start with 'search' + current-step tools. Add eager tools only if profiling shows the LLM always needs them.

Security

Permissions, secrets, blast radius

Credential storage: Your MCP server handles its own credentials — concierge doesn't impose a model

Data egress: Whatever your tools call

As an SDK, concierge's threat model is inherited from how you use it. Validate inputs in each tool.
Session isolation protects state per-user but shared external resources still need their own locks.

Troubleshooting

Common errors and fixes

Tools not appearing in the expected step

Check the step arg on @concierge.tool. A tool with step=['create'] is invisible during collect.

Verify: Call the search_tools tool; if nothing returns, your allowlist is wrong

Semantic search returns no results

Tool descriptions may be empty. Concierge builds embeddings from docstrings — fill them in.

Workflow state lost between calls

Concierge state is session-scoped. Ensure your client is sticky (same MCP session across calls).

Alternatives

concierge vs others

Alternative	When to use it instead	Tradeoff
fastmcp (Python)	You want the most popular Python MCP SDK without progressive disclosure	Lighter, but no built-in workflow/tool-gating features
Official MCP Python SDK	You want zero framework, closest to the spec	More boilerplate; you build gating yourself
TypeScript MCP SDK	Your stack is TS/Node	Different language; no direct concierge equivalent

More

Resources

📖 Read the official README on GitHub

🐙 Browse open issues

🔍 Browse all 400+ MCP servers and Skills