An open-source AI-powered App Store platform.
Describe your app in one sentence, and AI generates the full-stack code instantly.
Create, manage, publish, and share AI applications — all from a single platform.
OpenShrimp turns natural language into fully functional AI-powered web applications. No boilerplate, no scaffolding — just describe what you want.
Describe your app idea in a single sentence, and OpenShrimp's coding agent generates the entire full-stack application — backend API routes, frontend UI, and database logic — all in seconds.
Already have an app? Tell OpenShrimp what to change in plain language. The AI agent reads your existing code, understands the context, and applies precise modifications — adding features, fixing bugs, or refactoring.
When an app crashes, OpenShrimp automatically catches the runtime error and offers one-click Auto-Fix. The agent reads the traceback, analyzes root cause, locates the buggy code, and applies a surgical fix — all without you touching a single line of code.
Even when there's no crash but the output is simply wrong, you can use Behavior Fix mode: describe what you expected, and the agent compares the actual vs. expected output to understand the gap and rewrite the logic accordingly.
Both modes support real-time supervision — you can guide the agent with additional messages during the fix process.
After every agent session (generation, editing, or debugging), OpenShrimp automatically extracts reusable skills from the conversation:
- User preferences — what you really wanted, style choices, constraints
- Debugging lessons — errors encountered, root causes, how they were fixed
- Architecture decisions — why certain patterns were chosen
- Potential extensions — features hinted at but not yet built
These skills are persisted per-app and loaded into context for future sessions. The agent gets smarter with every interaction — it won't repeat past mistakes and will respect your preferences.
Publish your apps to a shared marketplace. Other users can discover, browse, and add public apps to their own workspace with one click.
Comes with ready-to-use apps out of the box:
- Excel Analyzer — Upload Excel files for AI-powered data analysis, pivot tables, and chart generation
- RAG Reader — Upload documents (PDF, TXT, etc.) for AI-powered reading and question answering with source citations
These built-in apps also serve as reference implementations — the coding agent can use them as templates when generating similar applications.
The coding agent is not just a prompt-to-code generator. It has a full developer toolbox:
| Tool | Description |
|---|---|
ls |
Browse directories — understand project structure |
read |
Read file contents — analyze existing code |
write |
Create new files — scaffold from scratch |
edit |
Surgical text replacement — modify without rewriting |
bash |
Run shell commands — test, install deps, check output |
update_app_features |
Toggle UI capabilities (e.g., enable file upload) |
The agent uses these tools in an autonomous iterative loop (up to 200 iterations): write code → execute → check errors → fix → repeat — just like a real developer.
Long agent sessions don't blow up the token budget. Every 5 iterations, OpenShrimp automatically compresses conversation history into a structured summary, preserving:
- Original user goal
- Files created or modified
- Key decisions made
- Errors encountered and resolutions
- Current progress state
This allows the agent to run 200+ iterations on complex tasks without losing context or hitting token limits.
You're always in control. While the agent is running:
- 📡 Live SSE Streaming — Watch every tool call, file modification, and agent thought in real-time
- 📝 Message Injection — Send guidance messages mid-generation (e.g., "don't use that library, use X instead")
- ⛔ Interrupt — Stop the agent at any point if it's going off track
- 🔍 Self-Verification — After generation, the agent automatically validates app structure, Python syntax, and module imports. If checks fail, it triggers an auto-repair loop.
Connect to any OpenAI-compatible LLM provider — OpenAI, Moonshot (Kimi), DeepSeek, Anthropic Claude, and more. Configure once in .env, and all apps share the same model.
Built-in JWT authentication with user registration, login, and role-based access. Each user has their own app workspace while sharing a common marketplace.
- Python 3.10+
- Node.js 18+
- An API key from any OpenAI-compatible LLM provider
- Clone the repository
git clone https://github.com/anthropics/openshrimp.git
cd openshrimp- Configure environment
cp .env.example .env
# Edit .env and fill in your LLM API key and base URL- Install backend dependencies
pip install -r backend/requirements.txt- Install frontend dependencies
cd frontend
npm install
cd ..- Start the backend
uvicorn backend.main:app --host 0.0.0.0 --port 8000 --reload --reload-exclude 'backend/apps/*'- Start the frontend (in a new terminal)
cd frontend
npm run dev- Open your browser at
http://localhost:5173
Default admin credentials:
admin/admin123
docker-compose up --buildAll configuration is managed through the .env file:
| Variable | Description | Example |
|---|---|---|
LLM_PROVIDER |
LLM provider type | openai |
LLM_API_KEY |
Your API key | sk-... |
LLM_API_BASE |
API base URL | https://api.openai.com/v1 |
LLM_MODEL |
Model name | gpt-4o |
LLM_MAX_TOKENS |
Max output tokens | 20000 |
PLATFORM_APP_NAME |
Platform display name | OpenShrimp |
AUTH_SECRET_KEY |
JWT secret key | (auto-generated if empty) |
openshrimp/
├── backend/
│ ├── agent/ # AI coding agent (generates & edits apps)
│ │ └── code_agent.py # Main agentic loop with tool use
│ ├── api/ # Platform REST API routes
│ ├── apps/ # Generated sub-apps (each is a FastAPI router)
│ ├── config/ # Settings & environment config
│ └── core/ # Shared services (LLM, DB, auth, registry)
├── frontend/
│ ├── src/
│ │ ├── pages/ # Login, Home, Market, App pages
│ │ ├── components/ # AgentModal, GenericApp, etc.
│ │ └── services/ # API client
│ └── ...
├── data/ # SQLite DB & generated outputs
├── docker-compose.yml
└── .env # All configuration lives here
How it works:
- User describes an app in the AgentModal (e.g. "Build a todo list with priorities")
- The Coding Agent receives the prompt and uses tools (
ls,read,write,edit,bash) to scaffold the app - The agent iterates autonomously — writing code, running tests, fixing errors — up to 200 iterations
- Self-verification checks structure, syntax, and imports; auto-repairs if anything fails
- A new sub-app directory is created under
backend/apps/<app_id>/with its own isolated.venv - Dependencies are auto-detected and installed; the app is registered and immediately available
- Skills are extracted from the session and saved for future context
- Users can iterate on the app with natural language edits, or use Auto-Fix for runtime errors
Contributions of all types are more than welcome!
- ⭐ Star this repo to show your support
- 🐛 Report issues and feedback
- 🔧 Submit pull requests
# Fork & clone
git clone https://github.com/dadiaomengmeimei/OpenShrimp.git
# Create a branch
git checkout -b feat/amazing-feature
# Make your changes, then
git commit -m "feat: add amazing feature"
git push origin feat/amazing-featureMIT © OpenShrimp