WeKnora Review: Tencent's Open-Source RAG + Wiki Platform

TL;DR

WeKnora is Tencent’s open-source knowledge platform — the engine behind the WeChat Dialog Open Platform — and it hit GitHub Trending this week at 25,863 stars (+3,034 in seven days). Where most self-hosted RAG tools stop at “upload PDFs, ask questions,” WeKnora ships three modes on one codebase: RAG Quick Q&A, a ReAct agent that orchestrates retrieval, MCP tools, web search, and session-persistent code sandboxes, and a Wiki Mode that distills raw documents into a self-maintaining, interlinked Markdown wiki with a knowledge graph, revision history, and rollback. Key facts as of September 17, 2026:

v0.8.0 (September 3, 2026): Docker / E2B / Cube skill sandboxes, a skill catalog (ClawHub, SkillHub, git, zip), and cross-session long-term memory
Go backend + Vue frontend, Python docreader parser, Postgres (pgvector) and Redis by default
Swappable everything: 17 LLM providers, 8 vector stores, 7 object-storage backends, 11 web-search providers
Retrieval: BM25 + dense hybrid, reranking, GraphRAG, parent-child chunking, editable chunks with revision history
Delivery: 10 IM channels (Slack, Telegram, Mattermost, WeCom, Feishu…), embed widget, Chrome extension, CLI, and an official MCP server with 29 tools
Enterprise plumbing: 4-tier workspace RBAC, audit logs, scoped API keys, OIDC, Langfuse tracing — all in the MIT-licensed repo, no enterprise tier
Caveat up front: config comments, API docs, and most issues are in Chinese

If you’ve outgrown AnythingLLM or Open WebUI’s knowledge feature and don’t want to build your own RAG pipeline, WeKnora is one of the most complete self-hosted options available right now.

Quick Reference


Repo	github.com/Tencent/WeKnora
Stars	25,863 (+3,034 this week), 3,527 forks, 662 open issues
Version	v0.8.0 (September 3, 2026); repo created July 22, 2025
Language	Go (backend, CLI), Vue/TypeScript (frontend), Python (docreader, MCP server)
License	MIT (bundled third-party components keep their own terms)
Install	`docker compose up -d` → http://localhost
Default stack	frontend, app, docreader, ParadeDB Postgres 17, Redis 7
Optional profiles	`neo4j`, `minio`, `langfuse`, `qdrant`, `milvus`, `weaviate`, `searxng`, `full`
Docs	Official site, API docs (Chinese)
Maintainer	Tencent WeChat team; ~80% of commits from one lead maintainer

WeKnora has shipped a release roughly every three weeks since July 2025. Three things converged this month:

v0.8.0 turned it into an agent platform, not just a RAG box. Skill sandboxes (Docker, E2B, or Tencent’s Cube) persist across a chat session, so the agent can install a docx skill from ClawHub, write a script, and hand you a generated Word file — the README’s hero screenshot is exactly that flow. The old host-process sandbox was removed for security.
Wiki Mode is the differentiator nobody else has. Agents distill a knowledge base into structured, interlinked wiki pages with an interactive graph; v0.7.2 added page revision history, line-level diffs, rollback, and in-browser editing. Wiki ingest scales to 40,000-document knowledge bases via a task queue with a dead-letter queue.
The Tencent name plus an MIT license. The RBAC, audit logs, and OIDC that other RAG projects sell as paid tiers are all in the repo.

How It Actually Works

Documents go into docreader (a Python gRPC service handling PDF, Word, Excel, PPT, EPUB, MHTML, XMind, images via OCR or a VLM, and audio via ASR), come out as chunks, and get indexed into whatever vector store and full-text engine you configured. The Go app service owns retrieval, reranking, the agent loop, sessions, RBAC, and a ~360-endpoint REST API. Redis backs the async task queue; Postgres holds metadata and, by default, the vectors via pgvector.

Three things stand out against a typical LangChain-style pipeline:

Retrieval is hybrid by default. Every knowledge base runs BM25 sparse plus dense retrieval, with optional reranking, parent-child chunking so hits carry surrounding context, and GraphRAG when you enable the Neo4j profile.

Chunks are first-class, editable objects. Open any retrieval chunk in the UI, edit it, diff it against previous versions, roll it back — WeKnora reindexes automatically. If you’ve spent a day debugging why a RAG system keeps citing a garbled table, this is the fix.

The agent has a real tool surface. Beyond retrieval: MCP tools (with OAuth2 and human-in-the-loop approval), web search across 11 providers, the skill sandbox with shell_exec and file tools, search_memory over the long-term memory store, and a final_answer tool. @Skill and @MCP mentions scope tools per turn.

Installation: Docker Compose in Five Minutes

Prerequisites: Docker with Compose, Git.

git clone https://github.com/Tencent/WeKnora.git
cd WeKnora
cp .env.example .env

The .env is heavily commented (in Chinese) and grouped A–J. The minimum for a working first boot:

WEKNORA_VERSION=v0.8.0        # pin a tag; 'latest' drifts
DEFAULT_LOCALE=en-US          # UI language; default is zh-CN
DB_DRIVER=postgres

SYSTEM_AES_KEY=<32-byte key>  # credential encryption at rest
JWT_SECRET=<random string>

# First-boot models via local Ollama (or set INIT_*_BASE_URL + API_KEY for a remote provider)
OLLAMA_BASE_URL=http://host.docker.internal:11434
INIT_LLM_MODEL_NAME=qwen3:8b
INIT_EMBEDDING_MODEL_NAME=bge-m3
INIT_EMBEDDING_MODEL_DIMENSION=1024
INIT_EMBEDDING_MODEL_ID=bge-m3

WEKNORA_BOOTSTRAP_SYSTEM_ADMIN_EMAIL=[email protected]

Then docker compose pull && docker compose up -d, open http://localhost, and register the bootstrap admin. The API is on :8080; --profile langfuse adds tracing on :3000.

Operational notes from the docs and issue tracker:

Upgrades: bump WEKNORA_VERSION, then docker compose pull && docker compose up -d. Migrations run automatically. up -d alone reuses cached images and can leave the UI behind the backend.
1024 dimensions is the sweet spot. HNSW indexing on pgvector is wired for 1024-dim embeddings; bge-m3 fits, OpenAI’s 3072-dim text-embedding-3-large won’t get the index.
PaddleOCR is fragile off x86. The FAQ recommends OCR_BACKEND=vlm with any vision model instead.
Lite mode exists. .env.lite.example runs on SQLite, local files, and an in-memory queue — fine for a laptop, not a team; sandboxes and GraphRAG are off.

Real Code: Ingest Docs and Ask Questions via the API

Everything in the UI is available over REST with an X-API-Key header. Scoped API keys (v0.7.0) grant capability-level permissions and can be restricted to specific knowledge bases.

import json, time, requests
from pathlib import Path

BASE = "http://localhost:8080/api/v1"
H = {"X-API-Key": "sk-your-scoped-key"}
KB = "kb-00000001"   # from the UI or GET /knowledge-bases

def upload(path: Path) -> str:
    with path.open("rb") as f:
        r = requests.post(f"{BASE}/knowledge-bases/{KB}/knowledge/file", headers=H,
            files={"file": (path.name, f)},
            data={
                "fileName": str(path),                       # keeps the folder tree
                "metadata": json.dumps({"source": "docs-sync"}),
                "process_config": json.dumps({
                    "chunking_config": {"chunk_size": 800, "chunk_overlap": 120},
                }),
            })
    r.raise_for_status()
    return r.json()["data"]["id"]

def wait_parsed(kid: str) -> None:
    while True:
        s = requests.get(f"{BASE}/knowledge/{kid}", headers=H).json()["data"]["parse_status"]
        if s == "completed": return
        if s == "failed": raise RuntimeError(kid)
        time.sleep(3)

for md in Path("docs").rglob("*.md"):
    wait_parsed(upload(md))

session = requests.post(f"{BASE}/sessions", headers=H,
                        json={"knowledge_base_id": KB}).json()["data"]["id"]

with requests.post(f"{BASE}/knowledge-chat/{session}",
    headers={**H, "Content-Type": "application/json"},
    json={"query": "How do we rotate the signing key in production?",
          "knowledge_base_ids": [KB],
          "agent_id": "builtin-quick-answer"},   # RAG mode; omit for the ReAct agent
    stream=True) as resp:
    for line in resp.iter_lines():
        if not line.startswith(b"data:"): continue
        ev = json.loads(line[5:])
        if ev["response_type"] == "references":
            for ref in ev["knowledge_references"]:
                print(f"[{ref['score']:.2f}] {ref['knowledge_title']} #chunk{ref['chunk_index']}")
        elif ev["response_type"] == "answer" and not ev["done"]:
            print(ev["content"], end="", flush=True)

The SSE stream sends a references event first (per-chunk scores, match type, source filename), then streams answer tokens, then a done: true frame. Append ?resource_urls=public and images inside citations come back as directly loadable links instead of resource:// handles.

The CLI and MCP server for agents

The weknora CLI (Go, build from cli/) is explicitly “agent-first”: every command emits a stable JSON envelope, error codes map to exit codes, and weknora schema dumps the machine-readable contract.

export WEKNORA_HOST=https://kb.example.com WEKNORA_API_KEY=sk-...   # no creds on disk
weknora link --kb engineering-docs
weknora doc upload runbook.md && weknora doc wait doc_abc
weknora search chunks "reciprocal rank fusion"
weknora chat "summarise the on-call runbook" --format text
weknora mcp serve                          # curated read-only MCP surface

For Claude Desktop, Cursor, or any MCP client, the official server is on PyPI:

{
  "mcpServers": {
    "weknora": {
      "command": "uvx",
      "args": ["--from", "tencent-weknora-mcp", "weknora-mcp-server"],
      "env": {
        "WEKNORA_API_KEY": "sk-...",
        "WEKNORA_BASE_URL": "http://localhost:8080/api/v1"
      }
    }
  }
}

That gives a coding agent 29 tools over stdio, SSE, or streamable HTTP. There’s also an official DeepSeek Harness plugin and a ClawHub skill for OpenClaw agents.

Wiki Mode: The Feature Worth Installing For

Every RAG tool answers questions. Wiki Mode is different: point an agent at a knowledge base and it writes a structured wiki — pages, cross-links, folder hierarchy, and a visual knowledge graph. It’s closer to Cognee’s graph memory than to a chatbot, but the output is human-readable Markdown your team can edit, diff, and roll back. The agent’s Q&A cites wiki pages in the references drawer, and the Feishu / Notion / GitLab / Yuque / RSS auto-sync connectors keep it fresh as sources change.

The obvious question is cost. Every wiki page is a generation call, and the most-commented open issue (#1679, 76 comments) asks for OCR, embedding, and wiki-map caches to be reused on rebuild instead of recomputed. Today, reparsing is a full recompute.

What the Community Is Saying

WeKnora’s growth has been GitHub-native and largely Chinese-language rather than Hacker News-driven — the one HN submission (December 2025) got 2 points. The maintainers post release threads on r/Rag and r/AgentsOfAI.

The issue tracker is the better signal:

#1679 (76 comments): reuse caches on reparse — the cost problem above
#1248 (49): thumbs up/down on answers — table stakes, still missing
#1418 (43): MySQL as primary database — now supported via DB_DRIVER=mysql
#1311 (38): multi-level folders — shipped as the folder tree in v0.7.2
#917 (23): tablet/phone layout — still open; the UI is desktop-first
#2985 (12): invite-only registration blocks invited users — an active RBAC bug

The pattern: requests get shipped within a release or two and the lead maintainer answers in-thread. The flip side is bus factor — one person authored roughly 80% of commits.

Honest Limitations

Documentation is Chinese-first. The README has English, Japanese, and Korean versions, but .env.example, docs/api/*.md, the FAQ, and the RBAC guide are Chinese. The v0.7.2 VitePress site (~50 pages, ~150 env vars) helps; you’ll still be translating.
It’s heavy. Five containers by default; the full profile adds MinIO, Neo4j, Qdrant, Langfuse, and SearXNG. AnythingLLM is one container.
Velocity outpaces stability. 662 open issues, a release every ~3 weeks, changelogs full of “harden” and “fix stale state.” Pin a version tag.
No answer feedback loop in the UI. There’s an E2E evaluation module (recall, BLEU, ROUGE), but everyday thumbs up/down is an open request.
Chinese-ecosystem gravity. IM channels lead with WeCom, Feishu, DingTalk, QQBot; data sources with Feishu, Yuque, Tencent IMA. Slack, Telegram, Notion, GitLab, and RSS are there; Google Drive, SharePoint, and Confluence are not.
Security is your job. The README recommends private-network deployment. Registration is open by default, the AES key and JWT secret are blank in the lite example, and the sandbox is opt-in for a reason.

Who Should Use This

Strong fit: teams wanting a self-hosted knowledge base with real RBAC and audit logs; anyone who wants the documents-to-wiki workflow and can afford the LLM spend; agent builders needing a retrieval backend with a clean MCP/CLI surface; organizations already on Feishu / WeCom / DingTalk.

Look elsewhere if: you want a one-container install for personal notes (AnythingLLM, Open WebUI); you need Confluence / SharePoint / Drive connectors out of the box; you’re embedding a RAG library in your own app rather than deploying a platform (CocoIndex for incremental indexing, RAG-Anything for multimodal); or your team can’t work with Chinese-language config docs.

How It Compares

	WeKnora	RAGFlow	AnythingLLM	Open WebUI
License	MIT	Apache-2.0	MIT	BSD-based with branding clause
Hybrid retrieval	BM25 + dense + rerank + GraphRAG	Yes, parsing-focused	Basic vector	Vector + BM25
Auto-wiki from docs	✅ graph, revisions, rollback	❌	❌	❌
Agent sandbox	Docker / E2B / Cube	Agent workflows	Limited	Tools
MCP	Official server (29 tools) + client	Client	Client	Client (via mcpo)
RBAC / audit	4-tier workspaces + audit log	Teams	Basic multi-user	Groups
IM channels	10	❌	❌	❌
Docs language	Chinese-first	English + Chinese	English	English
Footprint	5+ containers	4+ containers	1	1

RAGFlow remains the closest competitor — both are enterprise-flavored, Chinese-origin RAG platforms with strong document parsing. RAGFlow’s edge is parsing quality and English docs; WeKnora’s is Wiki Mode, the agent sandbox, IM distribution, and the agent-first CLI/MCP surface.

FAQ

Is WeKnora free for commercial use? Yes. The core is MIT-licensed; bundled third-party components keep their own licenses (listed in THIRD_PARTY_NOTICES.md). No enterprise edition gates RBAC, SSO, or audit logs. A hosted “WeKnora Cloud” offers managed LLM and parsing if you don’t want to bring your own models.

Does it run fully offline with local models? Yes. Point OLLAMA_BASE_URL at a local Ollama, use bge-m3 (1024-dim) for embeddings, keep pgvector, set OCR_BACKEND=vlm with a local vision model or disable OCR, and skip web search. Wiki Mode and the ReAct agent will be slow on an 8B model.

How is WeKnora different from RAGFlow? Same category, different emphasis. RAGFlow leads with deep document-layout parsing and English documentation. WeKnora leads with Wiki Mode, session-persistent code sandboxes, ten IM channels, and a CLI/MCP surface built for AI agents to drive. Pick RAGFlow for messy scanned PDFs; pick WeKnora for a living wiki and IM delivery.

Can Claude Code or Cursor use my WeKnora knowledge base? Yes. The tencent-weknora-mcp PyPI package runs an MCP server with 29 tools over stdio/SSE/HTTP, or build the CLI and run weknora mcp serve for a curated read-only surface. The CLI’s JSON envelope and exit-code matrix are documented in cli/AGENTS.md specifically for agents.

What does the skill sandbox actually do? As of v0.8.0 the agent can run code and skills inside a session-persistent Docker container, an E2B sandbox, or Tencent Cube, with a per-tenant network policy. Skills install into a workspace catalog from ClawHub, SkillHub, git, or zip; the agent gets shell_exec, file tools, and artifact output — the README demo generates a Word document.

How much hardware does it need? No official sizing guide exists. Expect the default five-container stack to want ~4 GB RAM idle before any model; the full profile realistically wants 8 GB+. Budget separately for Ollama if models are local.

Verdict

WeKnora is the most feature-complete self-hosted knowledge platform we’ve reviewed this year, and the only one that turns a pile of documents into a maintained wiki rather than just a chat box. The retrieval stack is serious, the agent layer got genuinely useful in v0.8.0 with persistent sandboxes and long-term memory, and the CLI/MCP surface is unusually thoughtful about being driven by other AI agents — all under MIT, with RBAC and audit logs others charge for.

The costs are real: Chinese-first docs, a five-container footprint, a fast-moving codebase with 662 open issues, and a full-recompute reparse model that makes iterating on chunking expensive. If your team can read config through a translator and pins a version tag, it’s worth a weekend: load 200 documents, enable Wiki Mode, and see whether the generated wiki is something your team would actually maintain. That test answers in an afternoon whether WeKnora’s core bet fits how you work.

⭐ Star WeKnora on GitHub →

Sources: Tencent/WeKnora README and CHANGELOG (v0.8.0, September 3, 2026); WeKnora API docs; cli/README.md; GitHub issues #1679, #1248, #1418, #1311, #917, #2985; r/Rag v0.2.0 thread; star counts from GitHub Trending and the GitHub API on September 17, 2026.

Related reading on andrew.ooo: