Concierge AI
Build Python MCP servers that reveal relevant tools by workflow step and enforce allowed call sequences.
- Source repo
- concierge-hq/concierge
- Stars
- ★ 528
- Last updated
- 4mo ago
- License
- NOASSERTION
- Primary language
- Python
- FA score
- 45/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platform
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- An e-commerce backend developer wants a shopping assistant to search products, manage a cart, and reach checkout in an allowed sequence.
- Not a fit if
- Teams that need a non-Python runtime
- Developers building applications without MCP
- Source review
- 45/100 · Major gaps 2 safety controls not found
What does this agent do, and when should you use it?
Concierge is an SDK for Python 3.9+ that wraps existing MCP servers or scaffolds new ones. It changes the tools returned by `tools/list` according to the active workflow step, with `stages` and `transitions` available to control tool visibility and step changes. Applications can share session-scoped state and optionally use semantic search to expose two meta-tools for large tool collections. Services can run over stdio, streamable HTTP, or SSE, and the package includes a `concierge init` scaffolding command. The README does not specify model providers, pricing, or a hosted service.
After installing concierge-sdk, a developer can wrap an existing FastMCP server with Concierge(FastMCP("my-server")); existing @app.tool() decorators, resources, and prompts remain usable. Tool names can be grouped in app.stages, while app.transitions defines permitted step changes. The service lists tools relevant to the current step and enforces the workflow ordering at the protocol level. Tools can read and write session state using app.get_state() and app.set_state(). For large tool collections, Config and ProviderType.SEARCH enable clients to discover tools with search_tools and invoke them through call_tool. Start with stdio using app.run(), or create an HTTP app with app.streamable_http_app(); the README also lists SSE transport.
- An e-commerce backend developer wants a shopping assistant to search products, manage a cart, and reach checkout in an allowed sequence.
- A team maintaining a FastMCP server wants progressive tool visibility while keeping its existing tools, resources, and prompts.
- A developer with hundreds of API tools wants semantic search to reduce how many tools the client sees at once.
- A service developer who needs workflow data shared across distributed replicas can evaluate the documented session-state feature.
- A Python team serving MCP clients over a CLI connection or a web deployment needs stdio or HTTP transport.
How do you install or deploy this agent?
Python 3.9+ is required. The README recommends uv and also supports pip; it does not list an API key requirement.
pip install concierge-sdkScaffold and start a project:
concierge init my-store
cd my-store
python main.pyHow do you use this agent?
To wrap an existing FastMCP server, the README provides this minimal example:
from mcp.server.fastmcp import FastMCP
from concierge import Concierge
app = Concierge(FastMCP("my-server"))Configure tool groups and allowed workflow transitions:
app.stages = {
"browse": ["search_products", "view_product"],
"cart": ["add_to_cart", "remove_from_cart", "view_cart"],
"checkout": ["apply_coupon", "complete_purchase"],
}
app.transitions = {
"browse": ["cart"],
"cart": ["browse", "checkout"],
"checkout": [],
}Run using the default stdio transport:
app.run()For a web deployment, create a streamable HTTP app:
http_app = app.streamable_http_app()What are this agent's strengths and limitations?
- Wraps an existing FastMCP server; the README says existing tool decorators, resources, and prompts continue to work.
stagesandtransitionscontrol tool visibility and call ordering at the MCP protocol level.- Session-scoped state passes data between workflow steps; the README says it works across distributed replicas.
- Semantic search can reduce a large API to the
search_toolsandcall_toolmeta-tools. - Supports stdio, streamable HTTP, and SSE transports and includes a
concierge initscaffolder.
- Requires Python 3.9+ and is not directly usable with other language runtimes.
- Workflows require developers to configure and maintain tool groups and allowed step transitions.
- The README does not identify the semantic-search provider, its costs, or its runtime dependencies.
- The supplied README does not give complete HTTP/SSE server configuration or production deployment instructions.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Concierge AI This agent | 45 · Major gaps | Library / SDK | ★ 528 | 4mo ago | Python | — |
| Vibe Check MCP | 81 · Good | MCP serverFree + model costs | ★ 501 | 1mo ago | TypeScript | Claude.ai · OpenAI API · Claude API |
| mcp-agent | 53 · Major gaps | FrameworkFree + model costs | ★ 8.6k | 8mo ago | Python | Claude.ai · OpenAI API · Claude API |
| MCP Memory Service | 68 · Some gaps | MCP serverFree | ★ 2k | today | Python | ChatGPT · Codex · Claude Code · Claude.ai |
How does FollowAgents rate this agent?
Why each dimension lost points
Stages and transitions can limit which tools are visible and callable, providing some least-privilege control (2). However, the checkout example has no confirmation step (user_confirmation 0), and no recovery mechanism for side effects is shown (rollback 0). Session-scoped state is described, but persistence, access control, and sensitive-data handling are not adequately explained (data_flow_transparency and sensitive_data_handling 1 each). Dependencies have broad minimum versions; CodeQL is present, but no dependency audit or lock evidence is provided (dependency_security 1). Tools can perform external actions such as purchases, with few safeguards documented (external_effects 1). Publisher identity is unverified and repository materials do not identify a maintainer, so attribution evidence is limited (source_attribution 1).
The README says Python 3.9+, while project configuration requires 3.10+; the claim of deterministic results is not supported by the supplied materials (self_consistency 1). Core and optional dependencies are listed, but there is no lockfile, compatibility matrix, or availability guidance (dependency_availability 1). The supplied materials show no error-message or error-handling conventions (failure_messages 0).
The documentation targets MCP server developers and covers e-commerce workflows, large tool sets, and CLI, HTTP, and SSE scenarios (audience_and_scenarios 2). It describes the boundaries of stages, transitions, state, and semantic search, and says these features are optional (capability_boundaries 2). It gives some cues for when to use features, such as semantic search for large tool sets (trigger_precision 2). Python requirements, installation, transports, and distributed state are documented, though deployment detail is limited (environment_fit 2).
The README has clear sections, a feature table, and documentation links (information_architecture 2). It provides pip installation, CLI scaffolding, and instructions for wrapping an existing MCP server (install_notes 2). Project, package, and CLI names are mostly consistent in the supplied materials (naming_stability 2). Code examples and documentation/community links are included, though no FAQ is shown (examples_and_faq 2). Some mechanism details are given, but limitations are not systematically listed (known_limitations 1). The README claims Apache 2.0, while LICENSE specifies the Sustainable Use License and separately restricts .ee files; licensing information conflicts (license 1). Configuration gives a version and a workflow describes generating unreleased changelog updates, but no current changelog file is supplied (versioning_changelog 1). Community and issue links exist, but maintenance responsibility is not assigned and publisher identity is unknown (maintenance_responsibility 1).
Progressive tool disclosure, shared state, and code examples give developers usable building blocks for MCP workflows (output_usability 2). Reducing irrelevant tools and enforcing workflow stages offer clear potential value (marginal_value 2). The basic path is concise and features are optional, but the materials do not quantify the benefits against added dependencies or production deployment costs (cost_benefit 2).
Core features have README examples and some corresponding state and component tests, but key product claims remain largely README assertions (claim_traceability 1). README, configuration, tests, and workflows provide only limited cross-checking (cross_source_corroboration 1). The materials distinguish examples from feature descriptions, but claims such as guaranteed determinism are not clearly identified as unverified assertions (fact_inference_separation 2).
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- The README and pyproject.toml disagree on the minimum Python version; the README and LICENSE also conflict on licensing. Verify the applicable license before use.
- Examples include external effects such as purchases but show no confirmation or rollback flow. Do not infer transaction safeguards from stage control alone.
FAQ
Do I need a model API key to use Concierge?
Can I keep my existing FastMCP tools?
Concierge(FastMCP("my-server")) and says existing @app.tool() decorators, resources, and prompts remain usable.How can I restrict tool call order?
app.stages and define permitted step changes in app.transitions; the README says Concierge enforces these constraints at the protocol level.Can I deploy it as a web service?
app.streamable_http_app() and lists stdio, streamable HTTP, and SSE transports. The supplied material does not describe full deployment configuration.