Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
curl -fsSL https://raw.githubusercontent.com/openmake/openmake_llm/main/install.sh | bash
On a fresh machine the installer sets up the prerequisites and the full stack (details below). With bash -s -- --minimal it installs only the app: it checks your toolchain (Node.js 24, Docker, PM2), writes a with fresh secrets, starts PostgreSQL and Redis, builds OpenMake, launches it under PM2, and runs a health check.
Open-source, self-hosted AI workspace for local and open-weight LLMs with vLLM, LiteLLM, autonomous agents, MCP tools, deep research, artifacts, and BYOK.
.envThen open the URL it prints, sign in as the administrator, and connect a model — a local vLLM or Ollama server, or any OpenAI-compatible endpoint.
Runs on Linux and macOS (Windows: inside WSL2). Manual setup, flags, updates, and reverse-proxy notes are in the self-hosting guide.
The one-liner hands off to the installer for your OS — install_linux.sh on Linux/WSL2, install_mac.sh on macOS. On a fresh machine it asks its questions once, then sets up the prerequisites (macOS: Xcode Command Line Tools, Homebrew, Colima (Docker) · Linux: distro packages, Docker Engine) and the full stack through scripts/env/omk.sh: LiteLLM gateway, SearXNG, sandbox images, internal HTTPS, backups, and auto-start after reboot. For a non-interactive install, pass the model backend too: --yes --dgx-host <host> --vllm-api-key <key> or --yes --llm-provider <name> --llm-model <id> --llm-api-key <key>.
Most self-hosted AI interfaces help you talk to a model. OpenMake is designed to coordinate models, tools, and agents so they can do the work — on infrastructure you control, with every step inspectable.
These projects sit at different layers, and they are not mutually exclusive: OpenMake serves local models through vLLM and can use an Ollama server as its model endpoint.
flowchart TB
R["Your request"] --> O["OpenMake<br/>plan · route · approve"]
O --> M["Models<br/>text · vision · image · speech · embedding"]
O --> A["Agents<br/>tasks · sub-agents · research"]
O --> T["Tools<br/>MCP · browser · files · code sandbox"]
M --> X["Answer · code · report · artifact"]
A --> X
T --> X
A simple question goes straight to your chat model. A request that needs more — an image, a transcript, a web search, a multi-step task — is split into tasks that run on the models and tools you assigned, and your chat model writes the final answer around the results.
You choose the models. OpenMake coordinates how they work together.
OpenMake does not require one model to do everything.
OpenMake
├── LiteLLM gateway (OpenAI-compatible)
│ ├── vLLM ─────────── your local / open-weight models
│ └── BYOK providers ─ OpenRouter · NVIDIA NIM · Ollama Cloud · Open AI Service Hub · B.AI
├── Direct ────────────── ChatGPT subscription login
└── Specialized models, assigned per capability
├── Text & code
├── Vision & OCR
├── Image generation & editing
├── Speech-to-text · text-to-speech · video
└── Embedding
agent, judge, research, spawn, review, summary, and planner. Users choose their own; administrators set defaults and can share server keys with daily and monthly token budgets.413 with an audit record.An agent task pursues a goal across many tool-calling turns. Agents can:
Available now
Opt-in — these ship disabled. Enable them in .env:
# macOS uses Colima; on Linux/WSL use `docker build` without `--context colima-openmake`.
docker --context colima-openmake build -t openmake-mcp-runtime:latest infra/mcp-runtime
docker --context colima-openmake build -t openmake-task-runtime:latest infra/task-runtime
Planned
Deep Research — breaks a question into sub-topics, searches them in parallel, reads the sources, summarizes in chunks, and writes a cited report. Wikipedia, Google News, and DuckDuckGo work without keys; SearXNG, Google Custom Search, Naver, and Kakao add coverage once configured.
Built-in tools — 23 tools for web search and fact-checking, page extraction and crawling, image analysis and OCR, planning, code and security review, skill loading, and Git importers. Most tools are offered only on turns that need them, which keeps prompts small.
MCP — install servers from the catalog (Tavily, Context7, Notion, NotebookLM, Kakao Map, OpenDART, and more) or register your own. Each stdio server can run in its own Docker container with dropped capabilities, a non-root user, and an optional read-only filesystem; remote servers sign in with OAuth.
Skills & extensions — install plugins, skills, custom agents, and MCP servers from Git, a zip, or a marketplace. Claude Code conventions — tool names, $ARGUMENTS, commands/, agents/, bundled scripts — are adapted on install, and anything that needs review lands in the Approvals inbox.
Artifacts — answers can render into sandboxed live previews; report requests become HTML artifacts exportable to PDF and DOCX, and a separate-origin viewer serves shared artifacts.
Integrations — an OpenAI-compatible API (/api/v1/chat/completions) with scoped API keys, a Discord gateway bot, and OpenMake Bench for comparing models before assigning them.
flowchart TB
subgraph clients["Clients"]
WEB["Web app · Next.js"]
NATIVE["Companion (macOS) · Code CLI"]
APIC["OpenAI-compatible API · Discord bot"]
end
clients -->|"REST · WebSocket"| API["API server · Express 5 + TypeScript"]
API --> PIPE["Message pipeline<br/>auth · policy · prompt & tool assembly"]
PIPE --> PLAN["Planner"]
PLAN --> CAP["Capability tasks"]
PIPE --> AGT["Agent runtime<br/>tasks · approvals · checkpoints"]
PIPE --> TOOLS["Tools · MCP"]
CAP --> LLM["LLMClient<br/>context-fit safety net"]
AGT --> LLM
TOOLS --> LLM
LLM --> GW["LiteLLM gateway"]
GW --> VLLM["vLLM · local models"]
GW --> EXT["BYOK providers"]
API --- PG[("PostgreSQL")]
API --- RD[("Redis")]
AGT --- SB["Docker sandboxes<br/>task · MCP · artifact"]
TOOLS --- SB
simple plan adds no extra model call. A multi plan is checked up front (assignments, key status, quotas), its tasks run by dependency level in parallel, and only successful media is attached to the answer.Calling a model is easy. Operating AI reliably is not. The hard parts are keeping state, enforcing permissions, executing safely, recovering from failure, and proving what happened. OpenMake is built around those:
A reference deployment is a single application host plus an inference host:
Application host Inference host (GPU)
┌──────────────────────────────────────────┐ ┌──────────────────────┐
│ PM2: API · web │ │ vLLM │
│ Docker: PostgreSQL · Redis · sandboxes │ ────► │ chat · embedding · │
│ LiteLLM gateway (OpenAI-compatible) │ │ image models │
└──────────────────────────────────────────┘ └──────────────────────┘
Everything can also run on one machine, or the model endpoint can be a hosted provider.
Day-to-day operation goes through openmake_llm.sh:
./openmake_llm.sh start # PostgreSQL → Redis → app, then stream logs
./openmake_llm.sh status # ports, containers, and PM2 state
./openmake_llm.sh update # git pull (fast-forward only) → build → migrate → restart
./openmake_llm.sh deploy # build → migrate → restart
./openmake_llm.sh stop
The installer writes a working .env. The essentials:
.env.example is the full reference, and many operational settings can be changed at runtime in Admin → System settings. Database migrations apply automatically on boot. For a public address, pass --public-url https://chat.example.com to the installer; a Caddy configuration is included under scripts/caddy/.
git clone https://github.com/openmake/openmake_llm.git
cd openmake_llm
npm install
npm run dev # API + web
npm test # shared packages, then Jest unit tests
npm run test:e2e # Playwright (chromium + webkit)
npm run lint # ESLint
apps/
├── api/ Express 5 API — chat pipeline, orchestrator, agents, MCP, data
├── web/ Next.js web app
├── cli/ OpenMake Code — local bridge CLI
├── desktop-native/ OpenMake Companion — SwiftUI menu-bar app (macOS)
├── ios/ SwiftUI iOS client (in progress)
└── discord-bot/ Discord gateway bot
packages/ shared types, API contracts, config, API client, local-bridge core
db/ baseline schema and migrations
infra/ Docker images and compose files for sandboxes and data stores
The direction is set; the schedule is not a promise — if a capability is not in a release, treat it as a plan. Details: openmake.cc/roadmap.
OpenMake is built in the open. We publish implementation notes, failures, trade-offs, and production lessons as we go:
Each week is also summarized in the weekly development log — latest: W42.
Contributions are welcome — bug reports, fixes, documentation, and new skills or MCP integrations.
main using Conventional Commits (feat, fix, refactor, docs, test, chore).npm run lint and npm test pass; schema changes include a migration; new environment variables are documented in .env.example; UI changes include a screenshot.CI runs a single CI Gate (test → build → size → lint) on every push and pull request.
Community & contact — questions and self-hosting help: [email protected] · maintainers: [email protected], [email protected]. If OpenMake is useful to you, a star helps other developers find it.
Released under the Apache License 2.0.
Open-source, self-hosted AI workspace for local and open-weight LLMs with vLLM, LiteLLM, autonomous agents, MCP tools, deep research, artifacts, and BYOK.
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Openmake Llm stdio पर लोकल चलता है।
पिछली जाँच 2026-10-27 को हुई। Open-source, self-hosted AI workspace for local and open-weight LLMs with vLLM, LiteLLM, autonomous agents, MCP tools, deep research, artifacts, and BYOK.