Synkora Ai

Synkora

Self-hosted AI agent platform. No cloud dependency. No vendor lock-in. Your infrastructure, your LLM keys.

Deploy agents to Slack, WhatsApp, Teams, Telegram, web widget, and REST API — from one platform. MIT licensed.

[](https://synkora.ai) [](#quick-start)

---

[](https://github.com/getsynkora/synkora-ai/actions/workflows/main-ci.yml) [](https://github.com/getsynkora/synkora-ai/actions/workflows/api-tests.yml) [](https://github.com/getsynkora/synkora-ai/actions/workflows/api-tests.yml) [](LICENSE) [](https://www.python.org/downloads/) [](https://nextjs.org/) [](https://github.com/getsynkora/synkora-ai/graphs/contributors) [](CONTRIBUTING.md)

[Features](#key-features) • [Quick Start](#quick-start) • [Documentation](#documentation) • [Contributing](#contributing) • [Community](#support--community)

---

---

Overview

LangChain gives you building blocks. AutoGen gives you patterns. Synkora gives you the entire platform.

Web UI, multi-tenant workspaces, RAG knowledge bases, 50+ tool integrations, multi-channel deployment, billing, scheduled tasks, HITL approval gates, and LLM observability — all self-hosted on your infrastructure, ready in minutes.

Why Synkora over building your own stack?

| | DIY with LangChain/CrewAI | Synkora | |---|---|---| | Agent UI | Build it | Included | | Multi-tenancy | Build it | Built-in | | RAG pipeline | Build it | Built-in | | Slack/WhatsApp/Teams bots | Build it | Built-in | | Billing & quotas | Build it | Built-in | | Human-in-the-loop approvals | Build it | Built-in | | LLM cost tracking | Build it | Built-in | | Self-hosted | Depends | Always |

• Platform, not a framework — No infrastructure code to write. Deploy agents from a web UI or REST API in minutes
• You own it — Self-host on your own servers. MIT licensed. No vendor lock-in, no phone-home
• Your LLM keys — OpenAI, Anthropic, Google, or any provider via LiteLLM. Switch anytime
• Multi-tenant by design — Per-tenant isolation, API keys, quotas, and model configs out of the box
• Deploy everywhere — Slack, WhatsApp, Teams, Telegram, web widget, REST API — from one platform

See It In Action

> Try it live at synkora.ai — no installation required.

Platform Overview

From agent definition to production deployment in minutes — API access, RAG, tool integrations, and multi-channel delivery.

Workspace Dashboard

Full workspace overview — agents, knowledge bases, data sources, MCP servers, and recent activity in one view.

Agent Library

Browse, search, and manage all your agents. Each card shows usage, success rate, and team visibility.

Agent Detail & Integrations

Per-agent configuration — integrations (Slack, WhatsApp, Telegram, databases), deployment channels, and advanced settings.

Live Agent Chat

Real-time streaming chat with quick-start action cards, session stats, and inline Lens observability.

Autonomous Mode

Schedule agents to run on any cadence — every 5 minutes to custom cron. Set tool budgets and enable Human-in-the-Loop approval.

Platform Engineer Agent

Create and manage agents through conversation. Describe what you want — no forms, no config files.

Full Navigation

Everything accessible from the sidebar — agents, knowledge bases, data sources, scheduled tasks, integrations, billing, and team management.

Key Features

What You Can Build

• Customer support agents - 24/7 query handling from your knowledge base, with HITL escalation to humans
• Engineering assistants - Code review, bug triage, and documentation via GitHub, GitLab, and Sentry
• Marketing automation - Content drafting, campaign analysis, and social scheduling
• Data agents - Natural language queries over your databases, automated reports, anomaly detection
• Internal copilots - HR, finance, and ops agents connected to your existing tools via 50+ integrations
• Personal AI assistants - General-purpose assistants with voice, browser control, and messaging integrations

Core Capabilities

• Multi-Provider LLM Support: OpenAI, Anthropic, Google, and more via LiteLLM — use your own keys
• Knowledge Bases: Vector-based knowledge management with Qdrant, Pinecone, and Elasticsearch
• Custom Tools: 50+ pre-built integrations plus extensible tool system
• Real-time Chat: WebSocket-based chat interface with streaming responses
• MCP Servers: Model Context Protocol server integration
• Voice Services: ElevenLabs integration for voice interactions

Enterprise Features

• Multi-Tenant Architecture: Complete tenant isolation with role-based access control
• Billing & Subscriptions: Stripe integration with plan-based resource limits
• SSO & Authentication: Okta SSO, SAML, and social authentication
• Messaging Bots: Slack, Microsoft Teams, and WhatsApp bot integrations
• Data Sources: Connect to databases, APIs, and external services
• Widgets: Embeddable chat widgets for websites
• Observability: Langfuse integration for LLM observability and analytics

Developer Experience

• RESTful API: Comprehensive FastAPI-based API with OpenAPI documentation
• Agent API Keys: Per-agent API keys for secure access
• Custom Domains: Configure custom domains for agents
• Activity Logs: Comprehensive audit trail
• Usage Statistics: Track usage and performance metrics

Architecture

> For a comprehensive technical analysis, see [ARCHITECTURE.md](ARCHITECTURE.md)

System Architecture

                    ┌─────────────────────────────────────────┐
                    │              Load Balancer                │
                    └────────────────┬────────────────────────┘
                                     │
              ┌──────────────────────┼──────────────────────┐
              │                      │                      │
    ┌─────────▼─────────┐ ┌─────────▼─────────┐ ┌─────────▼─────────┐
    │   FastAPI Pod 1    │ │   FastAPI Pod 2    │ │   FastAPI Pod N    │
    │  (API + WebSocket) │ │  (API + WebSocket) │ │  (API + WebSocket) │
    └─────────┬─────────┘ └─────────┬─────────┘ └─────────┬─────────┘
              │                      │                      │
    ┌─────────▼──────────────────────▼──────────────────────▼─────────┐
    │                        Redis (Pub/Sub + Cache)                   │
    └─────────┬──────────────────────┬──────────────────────┬─────────┘
              │                      │                      │
    ┌─────────▼─────────┐ ┌─────────▼─────────┐ ┌─────────▼─────────┐
    │  Celery Workers    │ │  Celery Beat       │ │  Bot Workers       │
    │  (default+billing) │ │  (scheduler)       │ │  (Slack/Telegram)  │
    └─────────┬─────────┘ └───────────────────┘ └─────────┬─────────┘
              │                                            │
    ┌─────────▼──────────────────────────────────────────-▼─────────┐
    │  synkora-ml (embeddings + reranking)                           │
    │  synkora-scraper (browser automation + app-store scraping)     │
    └────────────────────────────────────────────────────────────────┘
              │
    ┌─────────▼──────────────────────────────────────────────────────┐
    │                                                                 │
    │  PostgreSQL (pgvector)  │  Qdrant  │  MinIO/S3  │  Elasticsearch│
    └─────────────────────────────────────────────────────────────────┘

Tech Stack

Backend:

• Framework: FastAPI (Python 3.11+)
• Database: PostgreSQL 14+ with pgvector extension
• Cache: Redis 7+
• Vector DB: Qdrant, Pinecone, Elasticsearch
• Task Queue: Celery with Redis broker
• ORM: SQLAlchemy 2.0
• Migrations: Alembic
• Validation: Pydantic v2

Frontend:

• Framework: Next.js 15.1 with App Router
• UI: React 19, Tailwind CSS
• State Management: Zustand
• HTTP Client: Axios
• Forms: React Hook Form with Zod validation

Infrastructure:

• Containerization: Docker & Docker Compose
• Orchestration: Kubernetes (Helm charts included)
• Storage: MinIO (S3-compatible) or AWS S3
• Observability: Langfuse for LLM tracking

Project Structure

synkora/
├── api/                    # Backend API (FastAPI)
│   ├── src/
│   │   ├── config/        # Configuration management
│   │   ├── core/          # Core functionality (database, cache, websocket)
│   │   ├── models/        # SQLAlchemy models
│   │   ├── schemas/       # Pydantic schemas
│   │   ├── controllers/   # API route handlers
│   │   ├── services/      # Business logic
│   │   ├── middleware/    # Custom middleware
│   │   └── tasks/         # Celery tasks
│   ├── migrations/        # Alembic database migrations
│   ├── tests/             # Test suite
│   └── pyproject.toml     # Python dependencies
│
├── web/                    # Frontend (Next.js)
│   ├── app/               # Next.js App Router pages
│   ├── components/        # React components
│   ├── lib/               # Utilities and API client
│   ├── hooks/             # Custom React hooks
│   └── types/             # TypeScript type definitions
│
├── services/
│   ├── ml/                # ML microservice (embeddings + reranking)
│   └── scraper/           # Scraper microservice (browser + app-store)
│
├── docker-compose.yml      # Local development environment
├── helm/                   # Kubernetes Helm charts
└── docs/                   # Documentation

Cost Efficiency

Five complementary optimizations reduce LLM API costs. Savings figures are either derived from provider-published pricing or from the benchmark script — no figures are estimated or invented.

| Optimization | Mechanism | Typical Savings | Notes | |---|---|---|---| | Anthropic Prompt Caching | cache_control injected automatically on system prompt + tools for supported models | ~90% on cached prompt tokens (cache reads billed at 10% of input rate — Anthropic pricing) | Automatic — no config needed. LLM still runs fresh; output quality unchanged. | | OpenAI Automatic Caching | Provider-managed prefix caching; Synkora tracks cached_tokens in usage logs | 50% on cached prefix tokens (OpenAI pricing) | Automatic at provider level. No Synkora configuration required. | | Response Cache | Redis exact-match cache with 6 correctness gates; bypasses LLM entirely on cache hit | 100% cost saving per cache-hit call | Opt-in: requires enable_response_cache: true in agent performance config. Only activates for deterministic calls (temp ≤ 0.1, no tool context, no time-sensitive content). | | Cost-Opt Routing | Routes queries to the cheapest configured model that passes a complexity gate | Depends on model price gap — no universal figure | cost_opt mode in model_router.py. Savings vary entirely by which models are configured; no benchmark figure is claimed. | | Batch API | Submits background LLM jobs via Anthropic/OpenAI batch endpoints via Celery | 50% discount on batch calls (Anthropic / OpenAI published pricing) | Applies to scheduled/async tasks only, not real-time chat. |

Benchmark Results

> Generated by api/tests/benchmarks/cost_benchmark.py. API-dependent tests require ANTHROPIC_API_KEY / OPENAI_API_KEY — run locally with real keys for live latency numbers.

Cost calculation — pricing resolution order: DB routing-rules override → _BUILTIN_COSTS → MODEL_COMPARISON_DATA → None (unknown).

| Model | In tokens | Out tokens | Cache read | Cache write | Input rate | Est. cost (USD) | |-------|----------:|----------:|-----------:|------------:|:----------:|----------------:| | claude-haiku-4-5-20251001 | 1,000 | 500 | 0 | 0 | $0.00025/1k | $0.00275000 | | gpt-4o | 1,000 | 200 | 0 | 0 | $0.00500/1k | $0.00700000 | | gpt-4o-mini | 2,000 | 400 | 0 | 0 | $0.00500/1k | $0.01400000 | | claude-haiku-4-5-20251001 (with cache) | 500 | 200 | 300 | 100 | $0.00025/1k | $0.00106375 | | claude-sonnet-4-6 (with cache) | 1,000 | 300 | 500 | 200 | $0.00300/1k | $0.00630000 | | Unknown model | 1,000 | 200 | 0 | 0 | unknown | — |

Anthropic prompt-cache savings — 2,000-token system prompt, 100 requests/day:

| Model | Daily cost (no cache) | Daily cost (with cache) | Saving | |-------|-----------------------:|------------------------:|-------:| | claude-haiku-4-5-20251001 | $0.050000 | $0.005575 | 88.9% |

Response cache correctness gates — six gates prevent stale hits:

| Gate | Condition | Result | |------|-----------|--------| | Opt-in | temp=0.0, role=user | ✓ cacheable | | High temperature | temp=0.8, role=user | ✓ skipped | | Tool context | temp=0.0, role=tool | ✓ skipped | | Time-sensitive | "what is the current price?" | ✓ skipped |

Cache key stability — cache is automatically busted when the agent is edited:

| Scenario | Same key? | |----------|:---------:| | Identical inputs | ✓ yes | | Agent re-saved (agent_updated_at changed) | ✓ different | | System prompt edited | ✓ different |

Unit tests: 23/23 passed — test_llm_cost_service.py (10) + test_llm_response_cache.py (13).

Implementation files:

| Feature | File | |---------|------| | Cost calculation + analytics API | api/src/services/billing/llm_cost_service.py | | Per-call token usage persistence (fire-and-forget) | api/src/services/billing/llm_cost_service.py | | LLM response cache (Redis, 6 gates, NX write, 50 KB cap, 1 h TTL) | api/src/services/cache/llm_response_cache.py | | DB model (llm_token_usage) | api/src/models/llm_token_usage.py | | Migration | api/migrations/versions/20260424_0001_add_llm_token_usage.py |

Running Benchmarks

cd api && python -m tests.benchmarks.cost_benchmark --provider anthropic --api-key $ANTHROPIC_API_KEY
cd api && python -m tests.benchmarks.cost_benchmark --provider openai --api-key $OPENAI_API_KEY

Comparison vs Other Platforms

> Research methodology: Each platform was investigated against its official docs, GitHub issues/PRs, and changelogs as of April 2026. Every cell is sourced — see footnotes. Legend: ✅ Native built-in feature · ⚡ Partial (manual setup or limited scope) · ❌ Not supported

| Feature | Synkora | Dify | Flowise | LangFlow | n8n | |---------|:-------:|:----:|:-------:|:--------:|:---:| | Anthropic prompt caching (cache_control) | ✅ | ⚡ [¹](#fn1) | ❌ [²](#fn2) | ❌ [³](#fn3) | ⚡ [⁴](#fn4) | | LLM response cache (Redis exact-match) | ✅ | ⚡ [⁵](#fn5) | ✅ [⁶](#fn6) | ❌ [⁷](#fn7) | ⚡ [⁸](#fn8) | | Smart model routing (complexity/cost-based) | ✅ | ⚡ [⁹](#fn9) | ⚡ [⁹](#fn9) | ⚡ [¹⁰](#fn10) | ⚡ [⁹](#fn9) | | Batch API (Anthropic / OpenAI async 50% discount) | ✅ | ❌ [¹¹](#fn11) | ❌ [¹²](#fn12) | ❌ [¹³](#fn13) | ⚡ [¹⁴](#fn14) | | Per-call token & USD cost tracking | ✅ | ✅ [¹⁵](#fn15) | ⚡ [¹⁶](#fn16) | ⚡ [¹⁷](#fn17) | ⚡ [¹⁸](#fn18) |

Footnotes

¹ Dify prompt caching — Anthropic only, via official plugin v0.3.10 (Apr 2026). Six opt-in per-call parameters (prompt_caching_system_message, prompt_caching_tool_definitions, etc.) in the LLM node UI. OpenAI prefix caching is transparent at provider level (Dify does nothing special). Gemini explicitly declined as "not planned" (issue #2121). Known bug: Haiku 4.5 cache shows 0% (issue #1946).

² Flowise prompt caching — No cache_control implementation. Open feature request [#4634](https://github.com/FlowiseAI/Flowise/issues/46

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: getsynkora
• Source: getsynkora/synkora-ai
• License: MIT
• Homepage: https://synkora.ai

Install and usage instructions live in the source repository linked above.