Imported from yoloshii/gigaxity-deep-research (SKILL.md). Install upstream with npx skills add yoloshii/gigaxity-deep-research. Copyright stays with the author.

Gigaxity Deep Research

A skill-format reference for any agent (Claude Code, Codex, Cursor, Hermes, plain-MCP) calling this server. For human-readable installation instructions, see README.md. For harness-agnostic routing logic and the pasteable instruction block (drop into your harness's global CLAUDE.md / AGENTS.md or a standalone agent's system prompt), see CLAUDE.md.

Quick Start

The MCP server exposes six tools — two primitives plus four deep-research tools. Pick one based on query type, call it, return the result to the user verbatim.

# Primitives — raw and combined behavior in one call
search(query)                           # Multi-source aggregation, no LLM
research(query)                         # Search + synthesis with citations, single call

# Deep-research tools — discrete steps, drive each independently
ask(query)                              # Fast conversational answer (direct LLM, no search)
discover(query)                         # Exploratory expansion + gap detection
synthesize(query, sources)              # Citation-aware fusion of pre-gathered content
reason(query, sources)                  # Synthesize + explicit chain-of-thought depth control

Workflow

Phase 1: Classify the query

Query class?
├── "what is X right now / when was X / latest version"
│     → Phase 2A (ask)
│
├── "tell me about X" (cold start, no prior context)
│     → Phase 2B (discover → read → synthesize)
│
├── "compare X vs Y" or "best practice for X"
│     → Phase 2C (parallel search → synthesize)
│
└── "why did X happen" or "explain reasoning behind X"
      → Phase 2D (reason)

Phase 2A: ASK (fast factual)

result = mcp__gigaxity-deep-research__ask(query="<query>")
return result

Token budget: ~500–1500. Latency: ~2–5 s.

Phase 2B: DISCOVER → READ → SYNTHESIZE (exploratory)

discovered = mcp__gigaxity-deep-research__discover(
    query="<query>",
    focus_mode="general",  # or academic, documentation, comparison, debugging, tutorial, news
    identify_gaps=True
)

# discovered.sources is a ranked list. Pick top 3-5 URLs.
top_urls = [s.url for s in discovered.sources[:5]]

# Read full content (use a parallel reader if your environment has one)
contents = parallel_read(top_urls)  # e.g. mcp__jina__parallel_read_url

# Fold into a citation-backed synthesis
result = mcp__gigaxity-deep-research__synthesize(
    query="<query>",
    sources=contents,
    preset="comprehensive"  # or fast, tutorial, academic, contracrow
)
return result

Token budget: ~5000–10000. Latency: ~10–20 s.

Phase 2C: SYNTHESIZE (cross-source comparison)

# Gather in parallel from multiple search providers
results = await asyncio.gather(
    docs_search(query),       # e.g. Context7 MCP
    code_search(query),       # e.g. Exa get_code_context
    web_search(query),        # e.g. Jina search_web
)

# Optional free middleware: rerank + dedup
ranked = jina_sort_by_relevance(query, results)
deduped = jina_deduplicate_strings(ranked)

result = mcp__gigaxity-deep-research__synthesize(
    query="<query>",
    sources=deduped,
    preset="contracrow"  # surfaces disagreements rather than averaging
)
return result

Token budget: ~5000–10000. Latency: ~10–20 s.

Phase 2D: REASON (CoT over evidence)

# Sources-aware: chain-of-thought synthesis over the pre-gathered evidence.
result = mcp__gigaxity-deep-research__reason(
    query="<query>",
    sources=evidence_list,
)
return result  # markdown text — the synthesized answer (the CoT is
               # consumed by the prompt and not echoed back; if the model
               # fails to emit the expected tags, the full raw response is
               # returned as a fallback)

Token budget: ~5000–15000. Latency: ~15–30 s.

If you do not have pre-gathered sources, drop the sources argument and use depth-controlled CoT instead:

result = mcp__gigaxity-deep-research__reason(
    query="<query>",
    context="<optional background>",
    reasoning_depth="deep"        # shallow / moderate / deep
)

API Reference

MCP tools (stdio)

All six tools return markdown strings, not JSON. Every tool also accepts an optional openrouter_api_key: str | None = None for per-request key override (omitted from the signatures below for brevity).

mcp__gigaxity-deep-research__search(
    query: str,
    top_k: int = 10
) -> str                      # markdown ranked results, no LLM call

mcp__gigaxity-deep-research__research(
    query: str,
    top_k: int = 10,
    reasoning_effort: Literal["low", "medium", "high"] = "medium"
) -> str                      # markdown: search + synthesis + citations

mcp__gigaxity-deep-research__ask(
    query: str,
    context: str = ""
) -> str                      # the LLM's response text, direct call (no search)

mcp__gigaxity-deep-research__discover(
    query: str,
    top_k: int = 10,
    identify_gaps: bool = True,
    focus_mode: Literal["general","academic","documentation","comparison","debugging","tutorial","news"] = "general"
) -> str                      # markdown: knowledge landscape + gaps + sources

mcp__gigaxity-deep-research__synthesize(
    query: str,
    sources: list[dict],      # {title, content, url?, origin?, source_type?}
    style: Literal["comprehensive","concise","comparative","academic","tutorial"] = "comprehensive",
    preset: Literal["comprehensive","fast","contracrow","academic","tutorial"] | None = None
) -> str                      # markdown: synthesis + citations (+ contradictions if preset enables)

mcp__gigaxity-deep-research__reason(
    query: str,
    context: str = "",
    sources: list[dict] | None = None,
    style: Literal["comprehensive","concise","comparative","academic","tutorial"] = "comprehensive",
    reasoning_depth: Literal["shallow", "moderate", "deep"] = "moderate"
) -> str                      # markdown: CoT response. If `sources` is provided,
                              # synthesizes over them; otherwise depth-controlled CoT
                              # over the model's own knowledge plus optional `context`.

For the JSON / typed shape, call the matching REST endpoints (/api/v1/<tool>) — see docs/reference/rest-api.md.

REST endpoints

Base URL: http://localhost:8000 (configurable via RESEARCH_HOST / RESEARCH_PORT).

All POST endpoints accept the optional header X-OpenRouter-Api-Key: <key> to override RESEARCH_LLM_API_KEY for that request.

Presets

Focus modes

Architecture

Error Handling

Composable dependencies

This skill works alone for synthesis. For the full deep research workflow, pair with the other six MCPs in the stack:

• mcp__exa-answer__exa_answer — quick factual lookups (1–2 s, citation-backed)
• mcp__context7__resolve-library-id → mcp__context7__query-docs — official library/API docs
• mcp__exa__get_code_context_exa — code-context examples
• mcp__exa__web_search_advanced_exa — category-filtered search (company, people, financial report, news, github, pdf)
• mcp__jina__search_web / mcp__jina__parallel_read_url — free-tier web access
• mcp__jina__extract_pdf / mcp__jina__guess_datetime_url — PDF layout, URL freshness
• mcp__brightdata_fallback__scrape_as_markdown — blocked-URL fallback (CAPTCHA / paywall / Cloudflare)
• mcp__gptr-mcp__quick_search / deep_research — social-first research (Reddit, X, YouTube)

Routing logic across all seven is in skills/research-workflow/SKILL.md. Sanitized JSON configs for all seven in docs/reference/mcp-configs.md.