What is 0Gora?

0Gora — 0G + agora, the public square where knowledge was exchanged. A community-crowdsourced knowledge base, built on 0G. Ask it anything; every answer is grounded, cited, and verified on 0G.

For people and AI agents alike — humans use the web, agents connect over MCP. Same verified brain.

What it's for

• A shared, open knowledge base for any community or domain — not a walled garden.
• Answers you can trust: each is generated and TEE-verified on 0G, with citations. No black box.
• One source of truth your team and your agents can query.

Where it fits

• Project/protocol docs that answer questions (our live demo: a 0Gora about 0G itself).
• A community or DAO knowledge commons.
• An internal knowledge base with verifiable answers.
• A knowledge tool your AI agents can call — and trust.

Using 0Gora

Two front doors, one verified brain.

Humans — the web

Open 0gora.temporalabs.com/app. Pick a knowledge base from the switcher (e.g. 0G or ERC-8226) when more than one is hosted, then ask — by default 0Gora auto-picks the best 0G model for each query (a short Auto routed to… line shows which model answered and why); pin a specific model from the picker if you prefer. Each answer shows inline citations [n] and a Verified on 0G seal. If a question isn't in the corpus, 0Gora answers from general knowledge instead of guessing.

Agents — MCP

Connect over MCP (hosted, Streamable HTTP): https://0gora.temporalabs.com/mcp

claude mcp add --transport http 0gora https://0gora.temporalabs.com/mcp

Tool	Args	Returns
ask_0gora	question, model?	answer + citations + verification (verified, model, chatID) + routing (chosen, reason) when the model is auto-picked
search_0g_knowledge	query, k?	raw passages + source URLs (no LLM)
list_models	—	the verified 0G models

model? accepts a specific id or "auto" (the default) to let 0Gora route. An agent gets knowledge it can verify came from a TEE-attested model on 0G — not just text. See ../src/mcp/README.md.

---

Next: Why 0G? · Inside 0Gora

Why 0G?

0Gora's promise is trust — you can verify where every answer came from. That comes from 0G.

The 0G stack

0G is infrastructure for decentralized AI: four pillars. 0Gora builds on them (colored by what it uses today).

• Chain — EVM L1 for AI; settlement and coordination.
• Compute — inference inside a hardware TEE, attested (TeeML). The pillar 0Gora runs on.
• Storage — decentralized data: immutable Log + mutable key-value.
• DA — high-throughput data availability.

Concepts: https://docs.0g.ai/concepts.

What 0Gora uses

Pillar	Today	Notes
Compute	✅ load-bearing	Every answer generated + TEE-verified on the direct broker. Remove it, 0Gora can't answer.
Storage	⛏ roadmap	Corpus is in Qdrant (off-chain) today; moving it to 0G Storage is next.
Chain	— candidate	Later: on-chain contribution / attribution.
DA	— unused	Out of scope.

One pillar load-bearing (Compute), one planned (Storage), two unused.

Architecture

question → hybrid retrieval (Qdrant) → numbered context → generation on 0G Compute (TEE) → verified (processResponse) → answer + citations + seal.

What "Verified on 0G" means

Models run on the 0G direct broker with verifiability = "TeeML": sealed in a hardware TEE, each response attested on-chain. 0Gora offers only TeeML models. Router-only models use TeeTLS (verifiable routing — weaker), so e.g. GLM-5.2 isn't offered.

Model catalog

Four TEE-verified models. The picker defaults to Auto (below); 0GM is the routing default + fallback.

Model	Lab	Lane (strengths)
0GM-1.0-35B-A3B (default · fallback)	0G Foundation	general, short — fastest, lowest cost
zai-org/GLM-5.1-FP8	Zhipu AI	reasoning, analysis
deepseek-v4-pro	DeepSeek	code, math, logic
qwen3.7-max	Alibaba	multilingual, long-context

All on the direct broker, all TeeML. The broker serves others too (deepseek-v4-flash, glm-5, qwen3.6-plus, gpt-5.4-mini, MiniMax-M3, …) — any can be swapped in via config. Per-model pages: https://pc.0g.ai/models.

Auto routing

By default 0Gora picks the best model per query — fast/cheap for easy turns, a specialist for hard ones — and that chosen model then generates and TEE-verifies the answer on 0G as normal. Two layers, cheapest first:

1. Heuristic (free). Obvious queries route by rule with zero extra model calls: a greeting → the fast model; a code fence / def … / SELECT … FROM → the code lane; math symbols → math; non-Latin script → multilingual; a very long query → long-context.
2. LLM classifier (cheap) — on 0G. For ambiguous queries, one short call on the cheap router model (default 0GM) running on 0G returns the best model id. That routing call is unverified — it only picks a model, it isn't the answer, so it stays fast and cheap. The answer the chosen model produces is always TEE-verified, with its own Verified on 0G seal.

If the chosen model's 0G provider is momentarily unavailable, the answer cascades to the default (0GM) — a query never dies because a specialist is unfunded. The footer shows which model actually answered ("⤷ Auto routed to …").

Routing is config-driven: the roster (models + their lanes), the default, and the router model all live in 0gora.config.json — strengths drives the choice, tier is advisory context for the classifier. Tune routing by editing config, no code change. Prefer a specific model? Pin it from the picker to bypass Auto.

---

Next: Inside 0Gora

Inside 0Gora

For developers: how 0Gora works, and how to run your own. The reusable framework lives in src/; a deployment is a small config folder under examples/ that drives it (the shipped one is examples/0g/). You found your own agora by copying that folder and editing config — you never touch src/.

0Gora's RAG design is influenced by Onyx; the implementation here is its own, built for this cup.

Retrieval (RAG)

• Ingest — fetch a URL / site / sitemap → clean (trafilatura) → chunk → embed (bge-small) → store.
• Query — hybrid retrieval: vector search (Qdrant) + BM25 keyword, fused with Reciprocal Rank Fusion (RRF) → top-k passages.
• Ground — passages become numbered context; the model cites them inline as [n].
• Relevance gate — if the top match is weak, skip retrieval and answer from the model's general knowledge (no citations) instead of refusing.

Corpus & storage

• The corpus is a Qdrant vector store. Each record = embedding + text + source URL.
• Updated by re-ingesting sources (re-run ingestion on a URL → chunks refreshed). Admin-curated today; open contribution is on the roadmap.
• Off-chain today; 0G Storage is the planned home, so the data layer is on 0G too.

Components

Service	Role
RAG API (FastAPI)	ingest, retrieve, generate · endpoints /chat, /search, /models, /config, /instances (co-hosted agoras)
0G inference (Node)	OpenAI-compatible front to the 0G broker; runs the model in a TEE and verifies (processResponse)
MCP server	agent surface (ask / search / list models / list agoras)
Web	landing, chat, docs
Qdrant	vector store

Deploy your own

0Gora runs as Docker containers wired by Docker Compose. The base compose in src/deploy/ defines the generic services; an example's compose.override.yml layers its config on top:

git clone https://github.com/TemporaLabs/0gora
cd 0gora
cp examples/0g/.env.example examples/0g/.env   # set your 0G wallet key (or keep ZEROG_MOCK=true)
docker compose -f src/deploy/docker-compose.yml \
               -f examples/0g/compose.override.yml \
               --env-file examples/0g/.env up -d --build

That brings up the RAG API, the 0G inference service, the MCP server, the web app, and Qdrant. The instance's branding, example questions, and seed corpus come from examples/0g/0gora.config.json — no secrets, mounted at runtime. Seed the corpus with examples/0g/seed.sh. Add -f src/deploy/docker-compose.prod.yml for TLS in production.

Optional voice input. Off by default. To enable: set "voice": { "enabled": true } in 0gora.config.json and deploy with the voice compose profile (--profile voice, or COMPOSE_PROFILES=voice in .env). That runs the self-hosted src/stt service (faster-whisper) — the mic then transcribes on-box (works in any browser, audio never leaves the stack). Without the profile, nothing voice-related is built or run, so the default deploy carries zero footprint.

Found your own: the fastest path is the scaffolder — npm create 0gora@latest my-agora clones the framework and generates a configured examples/<slug>/ for you. (By hand: copy examples/0g to examples/<your-topic>, edit 0gora.config.json and .env, bring it up with your folder's overlay.) Same framework, a brand-new verifiable agora.

Use one (agents): npx 0gora-mcp connects any MCP agent to a running 0Gora, or drop in the src/skill/ skill to teach an agent to join one and found its own.

---

Next: What is 0Gora? · Why 0G?