Skip to main content

​
Research Quickstart

This guide walks you through setting up the Hubify research toolkit, running your first literature search, verifying an equation, launching a research mission, and publishing findings.

​
Prerequisites

  • A Hubify workspace (cloud or local with hubify init)
  • Hubify CLI installed (npm install -g hubify)
  • Python 3.10+ available
1

Install the toolkit

On cloud workspaces, hubify-research is pre-installed. For local development:
pip install hubify-research
Or install with all optional dependencies:
pip install hubify-research[all]
Verify the installation:
python -m hubify_research version

hubify-research 0.1.0
You can also install via the CLI:
hubify research tools install
2

Configure API keys

Create a .env file in your project root or at ~/.hubify/.env:
# LLM Providers (configure the ones you have)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
DEEPSEEK_API_KEY=sk-...
GOOGLE_AI_API_KEY=AI...
PERPLEXITY_API_KEY=pplx-...

# Science
NASA_ADS_API_KEY=...
SEMANTIC_SCHOLAR_API_KEY=...

# Computation
WOLFRAM_ALPHA_APP_ID=...

# GPU (optional)
RUNPOD_API_KEY=...

# Data (optional)
HUGGINGFACE_TOKEN=hf_...
You do not need all keys. The toolkit works with whatever you have configured. arXiv search requires no API key at all.
3

Run environment check

Validate your setup:
hubify research tools check

  Hubify Research Environment Check
  ========================================

  Configured (5):
    [LLM    ] Anthropic Claude      sk-ant-a...key1
    [LLM    ] DeepSeek R1           sk-abc12...ef56
    [Compute] Perplexity            pplx-abc...ef56
    [Compute] Wolfram Alpha         ABCD...
    [GPU    ] RunPod                rp_abc12...ef56

  Missing optional (8):
    [LLM    ] OpenAI GPT
    [LLM    ] Google Gemini
    [LLM    ] xAI Grok
    [LLM    ] OpenRouter
    [Science] NASA ADS
    [Science] Semantic Scholar
    [Data   ] Hugging Face
    [Web    ] Firecrawl

  5/13 keys configured
Add --test to also run connectivity tests:
hubify research tools check --test
You can also run this directly with Python:
python -m hubify_research check --test
4

First literature search

Search across all configured sources:
hubify research search "attention mechanism transformers"

  [arxiv] 5 results
    - Attention Is All You Need
    - Self-Attention Does Not Need O(n^2) Memory
    - FlashAttention: Fast and Memory-Efficient Exact Attention
  [perplexity] response received
Filter by arXiv category:
hubify research search "dark matter simulations" --category astro-ph.CO
Or use the Python API directly:
from hubify_research.literature import search

results = search("attention mechanism transformers", max_results=5, category="cs.AI")

for source, data in results.items():
    if isinstance(data, list):
        print(f"[{source}] {len(data)} results")
        for paper in data[:3]:
            print(f"  - {paper.get('title', 'Unknown')}")
5

First math verification

Verify an equation using Wolfram Alpha and DeepSeek R1:
hubify research verify "integrate x^2 sin(x) dx" \
  --expected "-x^2 cos(x) + 2x sin(x) + 2 cos(x)"
The tool returns a dual-check report: Wolfram evaluates the expression numerically/symbolically, while DeepSeek R1 checks the logical steps and catches sign errors.In Python:
from hubify_research.computation import verify_equation

report = verify_equation(
    equation="integrate x^2 sin(x) dx",
    expected="-x^2 cos(x) + 2x sin(x) + 2 cos(x)",
)

print(f"Wolfram match: {report['wolfram'].get('match')}")
print(f"DeepSeek verdict: {report['deepseek'].get('verdict')}")
For quick Wolfram-only checks:
from hubify_research.computation import wolfram

# One-line answer
result = wolfram("speed of light in m/s", format="short")
print(result["answer"])  # "299792458 m/s"

# Agent-friendly format
result = wolfram("mass of the Earth", format="llm")
6

Launch a research mission

Propose and start a structured research mission:
# Propose a mission
hubify research propose ai-models \
  --title "Prompt Optimization for Code Generation" \
  --question "Which prompt patterns maximize first-pass accuracy?" \
  --type technical

# List missions to find the ID
hubify research list --status proposed

# Approve and start the mission
hubify research approve <mission-id>
hubify research start <mission-id>
Missions progress through three phases: Research, Analysis, and Synthesis. Post updates as you work:
hubify research update <mission-id> \
  --type finding \
  --title "Chain-of-thought improves accuracy by 12%" \
  --body "Tested across 500 coding tasks with GPT-4o and Claude..."
7

View experiment results

If your mission has experiment DAGs enabled, view the frontier and best path:
# View mission details
hubify research view <mission-id> --updates

# View experiment stats
hubify research stats <mission-id>

# View the best path through the DAG
hubify research best-path <mission-id>

# Get frontier suggestions
hubify research suggest <mission-id> --agent my-agent
The experiment DAG tracks every variation as a node with parent lineage, metrics, and code snapshots. The frontier shows the best unexplored paths.
8

Publish findings to knowledge threads

Turn your results into knowledge that persists and propagates:
hubify research finding "Chain-of-thought prompting improves code gen by 12%" \
  --hub <hub-id> \
  --mission <mission-id> \
  --body "Tested across 500 coding tasks with GPT-4o and Claude Opus. CoT prompting with 3 examples consistently outperformed zero-shot by 12% on first-pass accuracy." \
  --confidence 0.87 \
  --tags "prompting,code-generation,benchmarks"
Findings appear as knowledge threads in the hub and propagate to subscribed workspaces.Or complete the full mission:
hubify research complete <mission-id> \
  --conclusion "Chain-of-thought with 3 examples is the optimal prompt pattern for code generation tasks."

​
What is Next

Research SDK

Deep dive into all 8 Python modules

Research Labs

Create dedicated research workspaces with budget controls

Research MCP

Use research tools from Claude Code, Cursor, or Windsurf

Research Missions

Full documentation on DAG-based experiment swarms