Cheshire Cat AI
An extensible Python framework for learning, researching, and publishing web-accessible AI agents.
The evidence distinguishes unauthenticated MCP connections from API-key bearer authentication and explicitly rejects missing tokens and unsupported OAuth2. Targeted tests also cover HTML escaping, redirect encoding, and asset-path traversal, supporting a moderate sensitive-data score. Deductions apply because the materials do not show a complete permission model, secret-storage or log-redaction policy, data-flow inventory, confirmation before external tool calls, or revocation/rollback mechanism. Remote MCP servers can contribute tools to an agent, but destinations and per-call authorization are not explained. The README, package metadata, and license identify the project, authors, and named maintainer, although publisher identity remains unverified by the enterprise registry and broader supply-chain provenance is absent. Dependencies use minimum constraints rather than a locked set, while CI lacks vulnerability scanning, dependency auditing, and an update policy.
The quick-start entry point, REST/UI surfaces, and several MCP, authentication, and UI error paths are supported across configuration and tests. Unknown resources, missing tokens, unsupported OAuth2, unknown login handlers, and missing assets have explicit failure behavior, earning a solid failure-messages score. The major deduction is a direct inconsistency: the README calls version 2 an unstable alpha unsuitable for production, while pyproject describes it as production-ready. Common dependencies and CI installation provide some availability support, but there is no lockfile, upper-bound strategy, offline path, or evidence that the resolved dependency set remains stable.
The README identifies education and research as the primary audience and also mentions publishing agents on the web; REST, UI, plugin, and MCP extension surfaces support multiple scenarios. The alpha warning and explicit rejection of unsupported OAuth2 provide useful boundaries. Deductions apply because supported and unsupported agent capabilities, models, deployment topologies, and security boundaries are not systematically documented. Tool-trigger conditions, conflict handling, and user restrictions on remote MCP tools are also absent. Python 3.11, a uv quickstart, a default port, and SQLite/Postgres dependency options provide ordinary environment guidance, but OS, container, production deployment, and resource requirements are missing.
The README has a compact structure covering quickstart, documentation, contribution, licensing, and issue paths; package name, CLI entry point, version, and project URLs are clear. The complete GPL-3.0 text agrees with package metadata, justifying full license credit. Publishing derives the PyPI package, tag, and generated release notes from the project version, providing a basic update path; the README names the founder/maintainer and supplies issue and contribution routes. Deductions reflect alpha-stage API and naming instability, only minimal examples and no FAQ, and limitations documented mainly through a broad alpha warning plus one OAuth2 restriction. There is no curated changelog, compatibility policy, support lifecycle, or explicit maintenance-response commitment.
The supplied evidence supports a launchable CLI, browser UI, REST API, and plugin mechanism that attaches MCP tools and reads resources. Tests show several outputs usable as HTTP responses, resource blocks, or tool results, supporting ordinary output usability. Deductions apply because claims such as being the best framework, easy to understand and extend, and used by institutions are assertions without comparisons, case studies, or measurements. Setup is short, but model/API expense, compute requirements, operational burden, latency, and scaling cost are not discussed; alpha status further weakens the demonstrated cost-benefit case.
Version, dependencies, entry points, CI and publishing behavior, licensing, and selected security/error behaviors are traceable to concrete configuration or tests. Some README statements are corroborated by those separate files. Deductions apply because evidence for the core product, security boundaries, and production characteristics is narrow: no architecture, substantive implementation files, full test results, or security audit is supplied. The README's superlative and adoption claims lack local corroboration, and the direct conflict between “Production ready” and “not recommended for production” shows that fact, aspiration, and marketing are not cleanly separated.
- The README explicitly labels version 2 an unstable alpha and advises against production use, while package metadata calls it production-ready; resolve this conflict and verify the actual release posture before deployment.
- Remote MCP servers can inject tools and resource-reading capability into the agent. The supplied materials show no per-call confirmation, tool allowlist, outbound-data disclosure, or revocation control, so remote servers should be treated as high-trust extensions.
- API keys become bearer credentials, but secret persistence, log redaction, rotation, and incident-response practices are not documented.
- Dependencies have minimum constraints without a supplied lockfile, security audit, or vulnerability scan; lock and review the complete resolved dependency graph before deployment.
- The publishing workflow has contents: write permission and uses a PyPI token. Independently verify branch protection, token scope, and release approvals because those controls are outside the supplied evidence.
What does this agent do, and when should you use it?
Cheshire Cat AI, also called Stregatto, is an AI agent microservice and Python framework aimed primarily at education and research. It is designed from the bottom up to make agent internals easier to understand and extend through plugin-oriented or agent-assisted development. Installing the `cheshire-cat-ai` package and running `ccat` exposes a local web UI and a REST API playground on port 1865. Repository topics associate the project with function calling, MCP clients, vector search, Docker, the AG-UI protocol, and plugins, although the supplied material does not document their concrete APIs or configuration. Version 2 is currently an unstable alpha with expected breaking changes, incomplete features, and rough edges, and it is explicitly not recommended for production.
The user creates a project environment with uv init --bare, adds the Python package using uv add cheshire-cat-ai, and starts the service with uv run ccat. The running service produces two local interfaces: a UI at http://localhost:1865 and a REST API playground at http://localhost:1865/docs. The project is positioned as a framework for studying how AI agents work and for publishing agents on the web. Its repository topics explicitly identify plugins, function calling, an MCP client, and vector search, but the supplied material contains no endpoint, class, configuration, or end-to-end input/output example for those features.
- A developer learning agent architecture can run the service locally and explore it through the UI and REST API playground.
- A researcher can use the Python framework as a modifiable base for educational or experimental agent work.
- A company or institution can evaluate publishing an agent on the web when alpha-stage instability is acceptable.
- A Python developer can use
uvto bootstrap a locally running agent-microservice prototype. - A protocol or plugin researcher can evaluate a repository associated with function calling, MCP clients, vector search, or AG-UI work.
What are this agent's strengths and limitations?
- The documented local setup requires only three
uvcommands to initialize, install, and launch the service. - One running service exposes both a web UI and a REST API playground for interactive and API-level exploration.
- The project explicitly prioritizes education, research, and understandable internals.
- It provides a locally runnable Python package path, with code licensed under GPL-3.0.
- Version 2 is an unstable alpha with explicitly expected breaking changes, incomplete features, and rough edges.
- The current release is expressly not recommended for production, creating upgrade and migration risk for adopters.
- The supplied material does not specify the Python version, model providers, credential setup, storage model, or production deployment procedure.
- Function calling, MCP, vector search, Docker, and plugins appear only as repository topics here, without verifiable usage flows or configuration examples.
- The project name and logo are owned by founder and maintainer Piero Savastano and are distinct from the GPL-3.0 licensing statement for the code.
How do you install or deploy this agent?
A command-line environment capable of running uv is required. The README does not specify a Python version, supported operating systems, instructions for installing uv, or model-service credentials. In an empty directory, run:
uv init --bare
uv add cheshire-cat-aiHow do you use this agent?
From the same directory, start the service with:
uv run ccatThen open http://localhost:1865 for the UI or http://localhost:1865/docs for the REST API playground. The supplied material does not provide copyable steps for creating an agent, selecting a model, configuring credentials, calling a specific API endpoint, or deploying the service publicly.
FAQ
Is it ready for production use?
What becomes available after startup?
http://localhost:1865, and the REST API playground is available at http://localhost:1865/docs.