Asoba Zorora Documentation
Home Insights Contact Us

Zorora: Deep Research Engine

Zorora is a local-deployment deep research engine that searches across academic databases, web sources, and newsroom articles, then synthesizes findings with credibility scoring and citation graphs. Built for macOS (Apple Silicon) with minimal RAM footprint, meant to be run directly from your computer, with all content, outputs, and chats stored locally and not in the cloud, giving you complete control and privacy.

Zorora Web UI Zorora Terminal REPL

Zorora offers both Web UI and Terminal REPL interfaces

What is Zorora?

Zorora transforms from a basic research tool into a deep research engine that:

  1. Searches EVERYTHING - Academic databases (7 sources) + web search + Asoba newsroom
  2. Follows citation trails - Multi-hop research that explores cited papers
  3. Cross-references claims - Groups similar claims and counts agreement across sources
  4. Scores credibility - Transparent rules-based scoring of source authority
  5. Builds citation graphs - Visualizes relationships between sources
  6. Synthesizes with confidence - Generates comprehensive answers with citation levels

Core Value Proposition

Zorora provides:

Core Features

Deep Research Capabilities

6-Phase Research Pipeline:

  1. Parallel Source Aggregation - Searches academic (7 sources), web (Brave + DDG), and newsroom simultaneously
  2. Citation Following - Multi-hop exploration of cited papers (configurable depth: 1-3)
  3. Cross-Referencing - Groups claims by similarity and counts agreement
  4. Credibility Scoring - Rules-based scoring of source authority (academic journals, predatory publishers, retractions)
  5. Citation Graph Building - Constructs directed graphs showing source relationships
  6. Synthesis - Generates comprehensive answers with confidence levels and citations

Research Depth Levels:

Additional Features

Architecture

Zorora uses deterministic routing with pattern matching instead of LLM-based orchestration. This design choice enables reliable operation with small 4B models while maintaining RAM efficiency.

Design Philosophy

Architecture Diagram

User Query / Slash Command / Web UI Request
    ↓
Pattern Matching (simplified_router.py) / Flask Routes (ui/web/app.py)
    ↓
    ├─→ DEEP RESEARCH WORKFLOW (6-phase pipeline)
    │   ├─► Phase 1: Parallel Source Aggregation
    │   │   ├─► Academic (7 sources: Scholar, PubMed, CORE, arXiv, bioRxiv, medRxiv, PMC)
    │   │   ├─► Web (Brave Search + DuckDuckGo)
    │   │   └─► Newsroom (Asoba API)
    │   ├─► Phase 2: Citation Following (configurable depth: 1-3)
    │   ├─► Phase 3: Cross-Referencing (groups claims by similarity)
    │   ├─► Phase 4: Credibility Scoring (rules-based)
    │   ├─► Phase 5: Citation Graph Building
    │   └─► Phase 6: Synthesis (Reasoning Model)
    ├─→ CODE WORKFLOW (Codestral specialist)
    ├─→ DEVELOPMENT WORKFLOW (/develop - multi-step)
    ├─→ FILE OPERATIONS (save/load/list)
    ├─→ IMAGE WORKFLOWS (generate/analyze)
    └─→ SIMPLE Q&A (/ask - direct model)

Key Principles

Core Components

1. Simplified Router (simplified_router.py)

Uses pattern matching to route queries to workflows. No LLM involved - pure pattern matching ensures consistent, fast routing (0ms decision time).

2. Research Engine (engine/research_engine.py)

High-level interface for deep research:

3. Deep Research Workflow (workflows/deep_research/)

Hardcoded pipeline for multi-source research:

4. Storage Layer (engine/storage.py)

Local-first storage:

5. Web UI (ui/web/app.py)

Flask-based web interface:

Local-First Design

Storage Architecture

Research Request
    ↓
ResearchEngine.deep_research()
    ↓
DeepResearchWorkflow.execute()
    ↓
LocalStorage.save_research()
    ├─► SQLite Index (~/.zorora/zorora.db)
    │   ├─► research_findings (metadata)
    │   ├─► sources (indexed)
    │   └─► citations (graph)
    └─► JSON Files (~/.zorora/research/findings/<id>.json)
        └─► Full research state (sources, findings, synthesis)

Privacy & Control

Performance

Why This Architecture?

Problem: 4B Models Can’t Orchestrate

Traditional multi-model orchestration requires the LLM to:

4B models fail at all of these. They can’t reliably generate JSON, struggle with function calling, and get stuck in loops.

Solution: Code Handles Complexity

Instead of asking the 4B model to be smart, we made the code smart:

Result: 100% reliability with 4B models, 1/3 the RAM usage of 8B orchestrators, complete privacy with local storage.

Trade-offs

What we lost:

What we gained:

Quick Start

Installation

Download v2-prod

Or install from GitHub:

pip install git+https://github.com/AsobaCloud/zorora.git

Run Your First Query

Terminal:

zorora
[1] ⚙ > What are the latest developments in large language model architectures?

Web UI:

zorora web
# Opens at http://localhost:5000

API:

from engine.research_engine import ResearchEngine

engine = ResearchEngine()
state = engine.deep_research("Your research question", depth=1)
print(state.synthesis)

Next Steps

See Also