Ga naar hoofdinhoud

Mercury 2-tutorial: een realtime, meerstaps onderzoeksagent bouwen

Leer hoe je Inception Labs’ Mercury 2, een op diffusie gebaseerd redenerend LLM, gebruikt om een latentie-bewuste onderzoeksagent te bouwen die zoekopdrachten uitbreidt, het web doorzoekt, een bron-gefundeerd antwoord synthetiseert en een verificatiepass uitvoert.
· 12 min lezen

Verken met AI

Mercury 2 is ontworpen voor productie-workloads waarin geredeneerd moet worden, zoals agent-workflows met zoek-, plannings- en retrieval-pijplijnen, waar traditionele autoregressieve modellen traag worden door sequentiële decodering. In deze tutorial gebruiken we Mercury 2 om met Streamlit een realtime, meerstaps onderzoeksagent te bouwen.

In de app stelt een gebruiker een complexe vraag, waarna het systeem deze uitbreidt naar meerdere gerichte zoekopdrachten, webresultaten parallel ophaalt, ze comprimeert tot gestructureerd bewijs en een bron-gefundeerd antwoord met inline citaties genereert. 

Een optionele verificatiestap beoordeelt de concepttekst aan de hand van het bewijs en verwijdert niet-onderbouwde beweringen. De interface stelt ook Mercury’s runtime-instellingen bloot, waaronder redeneringsinspanning, streamingoutput en diffusie-achtige streaming die laat zien hoe het antwoord in realtime wordt verfijnd.

Onderweg leer je hoe je:

  • Mercury 2 integreert via de OpenAI-compatibele API
  • Het runtime-gedrag aanstuurt met reasoning_effort en andere redeneringsknoppen
  • streaming en diffusing-modus inschakelt om iteratieve verfijning in realtime te visualiseren
  • Een latentie-bewuste agentpijplijn bouwt met parallelle zoekopdrachten en gestructureerde planning
  • Een interactieve Streamlit-interface maakt 

De uiteindelijke applicatie geeft een zoekplan, bewijssources en stap-voor-stap latentie terug, waardoor het systeem zowel snel als inspecteerbaar is.

Wat is Mercury 2?

Mercury 2 is Inception Lab’s snelle redeneringsmodel, ontworpen voor productie-workloads waar latentie zich opstapelt in agentloops, retrievalpijplijnen en toepassingen met hoge gelijktijdigheid. 

In tegenstelling tot standaard autoregressieve LLM’s die één token per keer decoderen, gebruikt Mercury 2 een diffusie-achtige generatie die tekst parallel verfijnt. Dat is de kernreden waarom het, met de juiste serving-setup, een extreem hoge throughput kan halen.

Belangrijke mogelijkheden van Mercury 2 zijn onder meer:

OpenAI-compatibele integratie

Mercury 2 biedt een OpenAI-compatibele API, waardoor je bestaande OpenAI-clientbibliotheken kunt gebruiken door simpelweg de basis-URL en modelnaam te wijzigen. Zo kun je het zonder SDK- of architectuurwijzigingen in bestaande applicaties, agentframeworks en productiepijplijnen plaatsen.

Ondersteuning voor lange context

Het model ondersteunt een contextvenster van ongeveer 128K tokens, geschikt voor workflows die grote bewijspakketten, meerstaps tool-uitvoer, conversatiesporen of gestructureerde tussentijdse status moeten doorgeven. 

Gestructureerde output en agent-gereed

Mercury 2 gaat betrouwbaar om met schema-beperkte JSON en ondersteunt tool-achtige interacties. Dit maakt use-cases mogelijk zoals queryplanning, argumentgeneratie voor tools, gestructureerde staatsoverdracht tussen stappen en verificatiepijplijnen waar deterministische opmaak telt.

Runtime-controles voor redeneren

In tegenstelling tot de meeste generieke modellen stelt Mercury 2 operationele regelaars bloot zoals reasoning_effort (instant tot hoog), optionele redeneringssamenvattingen, streamingoutput en diffusie-achtige streaming. Met deze knoppen kun je per call de afweging tussen snelheid, diepgang en interactiviteit afstemmen, afhankelijk van de fase in de pijplijn.

Productiegericht kostenmodel

De prijsstructuur is geoptimaliseerd voor workloads met hoge frequentie, met lage input-tokenkosten en aanzienlijk gereduceerde kosten voor gecachte inputtokens. Dit is gunstig voor agentloops en meerstaps pijplijnen waar systeemprompts en context over meerdere modelcalls worden hergebruikt.

Model pricing

Figuur: Modelprijzen

Hoe werkt Mercury 2?

Traditionele LLM’s genereren tekst autoregressief, waarbij ze één token per keer in volgorde produceren.

token 1 - token 2 - token 3… 

Dit koppelt latentie sterk aan de outputlengte, omdat elk token van het vorige afhangt, waardoor de latentie lineair groeit met de lengte. Dat wordt een bottleneck in agentsystemen waar je per gebruikersverzoek meerdere modelcalls doet.

Mercury 2 kiest een andere aanpak. In plaats van sequentiële decodering gebruikt het een door diffusie geïnspireerd, parallel verfijningsproces. Het model genereert een initiële concepttekst en verfijnt vervolgens meerdere tokens tegelijk over een klein aantal stappen. 

Generatie gedraagt zich meer als iteratief redigeren dan als stap-voor-stap typen, wat de throughput verbetert en de end-to-end latentie in meerstaps pijplijnen verlaagt.

Dit verfijningsproces maakt ook de diffusing-modus mogelijk, waarbij tussentijdse concepten worden gestreamd en in de UI geleidelijk worden verbeterd. Gebruikers kunnen in realtime zien hoe de tekst naar zijn definitieve vorm evolueert, wat vooral nuttig is voor demo’s, interactieve toepassingen en live onderzoeksinterfaces.

Door deze architectuur is Mercury 2 het best geschikt voor systemen waar latentie zich opstapelt over meerdere redeneerstappen in plaats van single-shot prompts. 

Mercury 2-tutorial: bouw een realtime, meerstaps onderzoeksagent

In deze sectie bouwen we een realtime onderzoeksassistent met Mercury 2 die een complexe vraag kan verwerken, het web doorzoekt, over meerdere bronnen redeneert en binnen enkele seconden een gefundeerd antwoord geeft. In plaats van één enkele prompt-responsinteractie draait het systeem een snelle meerstaps agentloop, waarbij elke stap de informatie verfijnt die nodig is voor een betrouwbaar resultaat.

Op hoofdlijnen voert de applicatie vijf kerntaken uit:

  1. Query-uitbreiding: We genereren meerdere gerichte zoekopdrachten (in gestructureerde JSON) om verschillende aspecten van de vraag te dekken.
  2. Parallelle webzoektocht: Vervolgens voeren we alle queries gelijktijdig uit om de latentie te minimaliseren en snel diverse bronnen te verzamelen.
  3. Bewijsnormalisatie: We schonen zoekresultaten op en comprimeren ze tot een compact evidence-JSON waar het model over kan redeneren.
  4. Gefundeerde synthese: We produceren ook een gestructureerd antwoord dat uitsluitend de aangeleverde bewijzen gebruikt, met inline citaties zoals [S1], [S2].
  5. Optionele verificatiepass: Gebruiker kan ook een tweede modelcall draaien die het conceptantwoord beoordeelt en claims die niet door het bewijs worden ondersteund, verwijdert of nuanceert. De verificatiefase past een lichte Generate-Critique-Fix-patroon toe, waarbij het model zijn eigen concept toetst aan het bewijs en het herziet voor sterkere feitelijke onderbouwing.

De applicatie levert twee hoofdoutputs op:

  • Bron-gefundeerde inzichten met inline citaties gekoppeld aan webbewijs.
  • Uitvoeringstransparantie, inclusief het gegenereerde zoekplan, de opgehaalde bronnen en stap-voor-stap latentie.

Demo

Stap 1: Krijg API-toegang

Voordat we de onderzoeksagent bouwen, hebben we eerst toegang nodig tot de Mercury 2 API. Omdat Mercury 2 momenteel via early access beschikbaar is, zorgt deze stap ervoor dat je de inloggegevens en endpointconfiguratie hebt die nodig zijn om vanuit je applicatie inferentie-calls te doen.

Je kunt hier toegang aanvragen: https://www.inceptionlabs.ai/early-access.

Zodra je account is goedgekeurd:

API Key creation

  • Geef een naam op en kopieer de gegenereerde sleutel

Bewaar deze sleutel veilig, want je gebruikt ‘m om alle API-verzoeken te authenticeren.

Let op: Je krijgt 10.000.000 gratis tokens bij de eerste aanmelding, voldoende om dit experiment uit te voeren.

Stap 2: Omgevingssetup

Nu je API-toegang hebt, is de volgende stap het voorbereiden van de lokale omgeving om de Mercury 2-onderzoeksagent te bouwen en draaien. Omdat de Inception API OpenAI-compatibel is, kunnen we de standaard OpenAI Python-client gebruiken, samen met een set libraries voor de webinterface en zoekpijplijn. We slaan onze API-sleutel ook op als omgevingsvariabele.

pip install streamlit openai aiohttp beautifulsoup4 lxml  
export INCEPTION_API_KEY="Your_API_Key”

We installeren de kern-afhankelijkheden die nodig zijn om de Mercury 2-onderzoeksagent te draaien en configureren veilige API-toegang. We gebruiken de standaard OpenAI-client voor modelcalls, Streamlit om de interactieve interface te bouwen, aiohttp voor parallelle webzoekopdrachten met lage latentie, en beautifulsoup4 met lxml om zoekresultaten te parsen. 

Na het installeren van de pakketten stel je je INCEPTION_API_KEY in als omgevingsvariabele om credentials veilig te houden en de applicatie tijdens runtime automatisch te laten authenticeren.

In de volgende stap implementeren we de Mercury-client en bouwen we de kern van de meerstaps agentpijplijn.

Stap 3: Mercury-client 

Deze stap verbindt drie zaken: het importeren van de libraries die we in de app gebruiken, het veilig laden van de API-sleutel uit de omgeving en het initialiseren van een OpenAI-client die naar Inception’s basis-URL wijst.

import os
import json
import asyncio
import time
import re
from dataclasses import dataclass
from typing import List, Dict, Any
import aiohttp
from bs4 import BeautifulSoup
import streamlit as st
from openai import OpenAI
INCEPTION_API_KEY = os.environ.get("INCEPTION_API_KEY", "").strip()
INCEPTION_BASE_URL = "https://api.inceptionlabs.ai/v1"
MODEL = "mercury-2"
if not INCEPTION_API_KEY:
    st.error("Missing INCEPTION_API_KEY. Set it in your shell: export INCEPTION_API_KEY='...'.")
    st.stop()
client = OpenAI(api_key=INCEPTION_API_KEY, base_url=INCEPTION_BASE_URL)

De bovenstaande code initialiseert een Mercury 2-client en importeert de ondersteunende stack voor de applicatie, waaronder Streamlit voor de UI, aiohttp voor asynchrone webverzoeken, BeautifulSoup voor het parsen van zoekresultaten en standaard Python-hulpprogramma’s voor JSON-afhandeling, timing en datastructuren.

We lezen vervolgens de INCEPTION_API_KEY uit de omgevingsvariabele, de Inception-basis-URL wordt geconfigureerd om verzoeken correct te routeren en de modelnaam is ingesteld op "mercury-2" zodat alle volgende calls het bedoelde redeneringsmodel gebruiken.

 Tot slot wordt de OpenAI-client geïnitialiseerd met de aangepaste basis-URL, zodat Mercury 2 kan worden aangeroepen via de standaard chat.completions-interface.

Stap 4: Webzoektool 

Vervolgens hebben we een retrievalstap nodig die actuele informatie van het web kan ophalen. In deze tutorial implementeren we een zoektool met DuckDuckGo’s HTML-endpoint en parsen we de resultaten direct, omdat er geen extra API-sleutels voor nodig zijn en het snel genoeg is voor prototyping.

Op hoofdlijnen implementeren we drie dingen:

  • Voer een zoekopdracht uit tegen de HTML-resultatenpagina van DuckDuckGo
  • Parse de toppresultaten naar een gestructureerd SearchResult-formaat
  • Dedupliceer en pak resultaten in een compact JSON dat Mercury later kan citeren
DDG_HTML = "https://duckduckgo.com/html/"
@dataclass
class SearchResult:
    title: str
    url: str
    snippet: str
def clean_text(s: str) -> str:
    return re.sub(r"\s+", " ", s or "").strip()
async def ddg_search(session: aiohttp.ClientSession, query: str, max_results: int = 4) -> List[SearchResult]:
    headers = {"User-Agent": "Mozilla/5.0 (compatible; MercuryResearchAgent/1.0)"}
    async with session.get(DDG_HTML, params={"q": query}, headers=headers, timeout=10) as resp:
        html = await resp.text()
    soup = BeautifulSoup(html, "lxml")
    out: List[SearchResult] = []
    for res in soup.select("div.result"):
        a = res.select_one("a.result__a")
        snippet = res.select_one("a.result__snippet") or res.select_one("div.result__snippet")
        if not a:
            continue
        title = clean_text(a.get_text())
        url = a.get("href", "")
        snip = clean_text(snippet.get_text() if snippet else "")
        if title and url:
            out.append(SearchResult(title=title, url=url, snippet=snip))
        if len(out) >= max_results:
            break
    return out
def dedupe_results(results: List[SearchResult]) -> List[SearchResult]:
    seen = set()
    uniq = []
    for r in results:
        key = r.url.split("#")[0].rstrip("/")
        if key in seen:
            continue
        seen.add(key)
        uniq.append(r)
    return uniq
def pack_evidence(results: List[SearchResult], max_items: int = 18) -> List[Dict[str, str]]:
    evidence = []
    for i, r in enumerate(results[:max_items], start=1):
        evidence.append({"id": f"S{i}", "title": r.title, "url": r.url, "snippet": r.snippet[:320]})
    return evidence

De bovenstaande utilities definiëren vier kernonderdelen:

  • Asynchrone webophaling: De functie ddg_search() doet een verzoek naar DuckDuckGo’s HTML-endpoint met aiohttp en parse’t de respons met BeautifulSoup en lxml. Elk resultaat wordt in een gestructureerd formaat gezet, en de functie stopt na max_results items om de latentie laag te houden. Zo kunnen meerdere zoekopdrachten parallel asynchroon worden uitgevoerd.
  • Tekstnormalisatie: De helper clean_text() verwijdert extra witruimte en opmaakartefacten, zodat snippets compact en leesbaar blijven. Resultaten worden opgeslagen met de SearchResult dataclass, die de output standaardiseert en latere stappen onafhankelijk van de ruwe HTML-structuur houdt.
  • Deduplicatie over queries heen: Wanneer de agent meerdere zoekopdrachten uitvoert, verschijnen dezelfde pagina’s vaak herhaaldelijk. De functie dedupe_results() verwijdert duplicaten door URL’s te normaliseren, zodat de evidence-set divers blijft en efficiënt binnen het contextvenster past.
  • Bewijspacking voor modelredenering: De functie pack_evidence() zet resultaten om in een compact JSON met stabiele identifiers. Snippets worden ingekort tot ~320 tekens zodat het gecombineerde bewijs binnen de context van het model past en later met inline citaties kan worden aangehaald.

Opmerking voor lezers:

Deze DuckDuckGo HTML-aanpak is prototype-vriendelijk omdat er geen extra API-sleutels voor nodig zijn, maar het is geen productierijpe zoekoplossing:

  • HTML-layouts kunnen veranderen en selectors breken
  • Rate limiting / botbescherming kan scraping blokkeren
  • Kwaliteit en ranking van resultaten kan variëren

Als je een productierijpe versie wilt, vervang dit dan door een stabiele Search API (SerpAPI, Bing Web Search, Google Programmable Search, Brave Search, enz.) en laat de rest van de agent ongewijzigd.

Vervolgens koppelen we deze retrievallaag aan Mercury 2 zodat het model zoekopdrachten kan genereren, over het verzamelde bewijs kan redeneren en een bron-gefundeerd antwoord kan produceren.

Stap 5: Mercury-calls

In deze stap kapselen we Mercury 2 in achter een kleine, herbruikbare interface die zowel strikte gestructureerde output (voor planning) als gestreamde tekstgeneratie ondersteunt (voor synthese en de diffusing-demo). 

Het doel is om elke modelcall consistent te houden, terwijl Mercury’s “redeneringsknoppen” en streamingmodi via één instellingenobject beschikbaar blijven.

def mercury_settings(
    reasoning_effort: str = "medium",
    reasoning_summary: bool = False,
    reasoning_summary_wait: bool = False,
    diffusing: bool = False,
) -> Dict[str, Any]:
    return {
        "reasoning_effort": reasoning_effort,
        "reasoning_summary": reasoning_summary,
        "reasoning_summary_wait": reasoning_summary_wait,
        "diffusing": diffusing,
    }

def mercury_json(
    system: str,
    user: str,
    max_tokens: int = 400,
    reasoning_effort: str = "medium",
) -> Dict[str, Any]:
    def _call(messages) -> str:
        resp = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            max_tokens=max_tokens,
            temperature=0.0,
            stream=False,
            extra_settings=mercury_settings(
                reasoning_effort=reasoning_effort,
                reasoning_summary=False,      
                reasoning_summary_wait=False,
                diffusing=False,
            ),
        )
        return (resp.choices[0].message.content or "").strip()

    text = _call(
        [{"role": "system", "content": system}, {"role": "user", "content": user}]
    )
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        pass
    m = re.search(r"\{.*\}", text, flags=re.DOTALL)
    if m:
        try:
            return json.loads(m.group(0))
        except json.JSONDecodeError:
            pass
    repair_system = "You are a JSON repair tool. Return ONLY valid JSON. No markdown, no commentary."
    repair_user = (
        "Fix the following so it is valid JSON and matches the required schema.\n\n"
        "REQUIRED SCHEMA:\n"
        "{\"queries\": [string], \"subquestions\": [string], \"must_cover\": [string]}\n\n"
        "BROKEN OUTPUT:\n"
        f"{text}"
    )
    fixed = _call(
        [{"role": "system", "content": repair_system}, {"role": "user", "content": repair_user}]
    )
    try:
        return json.loads(fixed)
    except json.JSONDecodeError:
        m2 = re.search(r"\{.*\}", fixed, flags=re.DOTALL)
        if not m2:
            raise ValueError(f"Non-JSON from model even after repair:\n{fixed[:1000]}")
        return json.loads(m2.group(0))

def mercury_text(
    system: str,
    user: str,
    max_tokens: int = 950,
    temperature: float = 0.3,
    reasoning_effort: str = "medium",
    reasoning_summary: bool = False,
    reasoning_summary_wait: bool = False,
    stream: bool = False,
    diffusing: bool = False,
    stream_callback=None,
) -> str:
    if diffusing:
        stream = True  
    extra_settings = mercury_settings(
        reasoning_effort=reasoning_effort,
        reasoning_summary=reasoning_summary,
        reasoning_summary_wait=reasoning_summary_wait,
        diffusing=diffusing,
    )
    messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
    if not stream:
        resp = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            max_tokens=max_tokens,
            temperature=temperature,
            stream=False,
            extra_settings=extra_settings,
        )
        return (resp.choices[0].message.content or "").strip()
    full = ""
    stream_resp = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        max_tokens=max_tokens,
        temperature=temperature,
        stream=True,
        extra_settings=extra_settings,
    )
    for event in stream_resp:
        choices = getattr(event, "choices", None) or []
        if not choices:
            continue
        delta = getattr(choices[0], "delta", None)
        chunk = (getattr(delta, "content", None) or "") if delta is not None else ""
        if not chunk:
            continue
        if diffusing:
            full = chunk
        else:
            full += chunk
        if stream_callback:
            stream_callback(full, {"delta": chunk})
    return full.strip()

In deze stap definiëren we helperfuncties met drie kernelementen:

  • Instellingen voor redeneringsknoppen: De functie mercury_settings() centraliseert Mercury-specifieke parameters zoals reasoning_effort, reasoning_summary, reasoning_summary_wait en diffusing. Dit houdt de pijplijn consistent en maakt het eenvoudig om Streamlit-toggles rechtstreeks aan elke modelcall te koppelen zonder configuratie te dupliceren.
  • Schema-uitgelijnde JSON-generatie: mercury_json() wordt gebruikt wanneer de agent gestructureerde output nodig heeft. Het draait met temperature=0.0 en schakelt streaming/diffusie uit om de formaatstabiliteit te maximaliseren. De functie probeert JSON direct te parsen, probeert dan via regex een JSON-blok te extraheren en valt ten slotte terug op een reparatiepass die het model dwingt geldige JSON te retourneren die aan ons vereiste schema voldoet.
  • Tekstgeneratie met optionele streaming en diffusie: De functie mercury_text() ondersteunt zowel niet-streaming als streaming modi. Als diffusing=True, wordt stream=True automatisch afgedwongen en wordt de weergegeven tekst bijgewerkt door de huidige buffer te overschrijven. In de normale streamingmodus worden deltas toegevoegd om het definitieve antwoord op te bouwen. De optionele hook stream_callback() laat de UI live updates renderen.

In de volgende stap gebruiken we deze helpers om gestructureerde query-uitbreiding te implementeren en ze te koppelen aan de webzoek- en bewijspijplijn.

Stap 6: Gestructureerde query-uitbreiding

Nu koppelen we Mercury 2 en webzoekopdrachten in een end-to-end onderzoekslus. Het kernidee is om eerst een gestructureerd zoekplan te genereren en vervolgens het definitieve antwoord te dwingen te steunen op de bewijslast, om Mercury’s redeneringscontroles en streaming/diffusing-modi in de UI te demonstreren.

def expand_query(question: str, n_queries: int = 6, reasoning_effort: str = "medium") -> Dict[str, Any]:
    system = (
        "Return ONLY valid JSON. No markdown.\n"
        "Schema: {\"queries\": [string], \"subquestions\": [string], \"must_cover\": [string]}\n"
        "Rules:\n"
        f"- MUST produce at least {max(3, n_queries-2)} queries\n"
        "- queries <= 12 words, diverse\n"
        "- include: definitions, official docs, benchmarks, edge deployment, counterarguments\n"
        "Output must start with '{' and end with '}'."
    )
    user = f"Question: {question}\nReturn {n_queries} queries."
    out = mercury_json(system, user, max_tokens=320, reasoning_effort=reasoning_effort)
    queries = (out.get("queries") or [])
    subqs = (out.get("subquestions") or [])
    must = (out.get("must_cover") or [])
    if len(queries) == 0:
        queries = [
            f"{question} benchmarks",
            "vLLM edge inference benchmarks",
            "llama.cpp edge inference benchmarks",
            "vLLM vs llama.cpp quantization",
            "llama.cpp Metal CUDA Vulkan performance",
            "vLLM KV cache paged attention memory",
        ][:n_queries]
    out["queries"] = queries[:n_queries]
    out["subquestions"] = subqs[: min(6, n_queries)]
    out["must_cover"] = must[:6]
    return out
def answer_with_citations(
    question: str,
    evidence: List[Dict[str, str]],
    *,
    reasoning_effort: str,
    reasoning_summary: bool,
    reasoning_summary_wait: bool,
    stream: bool,
    diffusing: bool,
    stream_callback=None,
) -> str:
    system = (
        "You are a fast research synthesizer.\n"
        "Use ONLY the provided evidence.\n"
        "Add inline citations like [S1], [S2] using evidence ids.\n"
        "If evidence is insufficient, say what's missing."
    )
    user = (
        f"Question:\n{question}\n\n"
        f"Evidence JSON:\n{json.dumps(evidence, ensure_ascii=False)}\n\n"
        "Deliver:\n1) Direct answer\n2) Key insights (3-6 bullets)\n3) Caveats/unknowns"
    )
    return mercury_text(
        system,
        user,
        max_tokens=950,
        temperature=0.3,
        reasoning_effort=reasoning_effort,
        reasoning_summary=reasoning_summary,
        reasoning_summary_wait=reasoning_summary_wait,
        stream=stream,
        diffusing=diffusing,
        stream_callback=stream_callback,
    )
def verify_answer(
    question: str,
    evidence: List[Dict[str, str]],
    draft: str,
    *,
    reasoning_effort: str,
) -> str:
    system = (
        "You are a verifier.\n"
        "Remove/soften any claim not supported by evidence.\n"
        "Keep citations [S#]. Return revised answer."
    )
    user = (
        f"Question:\n{question}\n\n"
        f"Evidence JSON:\n{json.dumps(evidence, ensure_ascii=False)}\n\n"
        f"Draft:\n{draft}"
    )
    return mercury_text(
        system,
        user,
        max_tokens=950,
        temperature=0.2,
        reasoning_effort=reasoning_effort,
        reasoning_summary=False,
        reasoning_summary_wait=False,
        stream=False,
        diffusing=False,
    )
async def run_agent(
    question: str,
    n_queries: int,
    max_results_per_query: int,
    do_verify: bool,
    *,
    reasoning_effort: str,
    stream_answer: bool,
    diffusing: bool,
    reasoning_summary: bool,
    reasoning_summary_wait: bool,
    stream_callback=None,
) -> Dict[str, Any]:
    t0 = time.perf_counter()
    plan = expand_query(question, n_queries=n_queries, reasoning_effort=reasoning_effort)
    t1 = time.perf_counter()
    queries = plan.get("queries", [])
    async with aiohttp.ClientSession() as session:
        tasks = [ddg_search(session, q, max_results=max_results_per_query) for q in queries]
        lists = await asyncio.gather(*tasks)
    flat = dedupe_results([r for lst in lists for r in lst])
    evidence = pack_evidence(flat, max_items=18)
    t2 = time.perf_counter()
    draft = answer_with_citations(
        question,
        evidence,
        reasoning_effort=reasoning_effort,
        reasoning_summary=reasoning_summary,
        reasoning_summary_wait=reasoning_summary_wait,
        stream=stream_answer,
        diffusing=diffusing,
        stream_callback=stream_callback,
    )
    t3 = time.perf_counter()
    final = verify_answer(question, evidence, draft, reasoning_effort=reasoning_effort) if do_verify else draft
    t4 = time.perf_counter()
    return {
        "plan": plan,
        "evidence": evidence,
        "answer": final,
        "timings_sec": {
            "expand": round(t1 - t0, 3),
            "search_parallel": round(t2 - t1, 3),
            "synthesize": round(t3 - t2, 3),
            "verify": round(t4 - t3, 3),
            "total": round(t4 - t0, 3),
        },
    }

Deze stap koppelt vier kernfases aan elkaar:

  • Gestructureerde queryplanning: De functie expand_query() genereert een gestructureerd onderzoeksplan door Mercury 2 te vragen strikte JSON te retourneren met queries, subquestions en must_cover. De output wordt geparsed met mercury_json(), inclusief automatische JSON-reparatie, en een fallback-set queries die ervoor zorgt dat de agent doorgaat, zelfs als het model een leeg plan terugstuurt.
  • Bewijs-gefundeerde synthese met citaties: De functie answer_with_citations() produceert de initiële respons met uitsluitend het gepakte bewijs uit de zoekfase. De prompt beperkt het model expliciet tot het aangeleverde bewijs en vereist inline citaties. De output bevat een direct antwoord, kerninzichten en kanttekeningen, zodat de respons beknopt blijft en herleidbaar is naar bronnen.
  • Optionele verificatie voor onderbouwing: De functie verify_answer() implementeert het Generate-Critique-Fix-patroon. Ze evalueert het conceptantwoord opnieuw aan de hand van hetzelfde bewijs en verwijdert of nuanceert niet-onderbouwde claims, terwijl citatiemarkers behouden blijven. Deze extra pass vermindert overgeneralisatie en verbetert de feitelijke onderbouwing met minimale latentie-overhead.
  • Orchestratie met prestatie-tracking: De functie run_agent() coördineert de volledige workflow, inclusief het uitbreiden van het queryplan, het uitvoeren van parallelle DuckDuckGo-zoekopdrachten met aiohttp en asyncio.gather(), het dedupliceren en inpakken van resultaten in compact evidence-JSON, het genereren van het gesynthetiseerde antwoord en optioneel het uitvoeren van verificatie. 

Stap 7: Streamlit-UI

Tot slot koppelen we de agenruntime (run_agent) aan een Streamlit-interface, zodat gebruikers een vraag kunnen invoeren, kunnen bepalen hoe de agent zoekt en het volledige uitvoeringsspoor kunnen inspecteren—eindantwoord, timings, het gegenereerde zoekplan en het bewijspakket.

st.set_page_config(page_title="Mercury 2 Research Agent", layout="wide")
st.title("Mercury 2: Real-Time Multi-Step Research Agent")
question = st.text_area(
    "Ask a complex question",
    height=120,
    placeholder="e.g., Compare vLLM vs llama.cpp for edge inference...",
)
col1, col2, col3 = st.columns(3)
with col1:
    n_queries = st.slider("Search queries", 2, 8, 4)
with col2:
    max_results = st.slider("Results per query", 1, 6, 2)
with col3:
    do_verify = st.checkbox("Verification pass", value=False)
with st.expander("Mercury settings", expanded=False):
    reasoning_effort = st.selectbox("reasoning_effort", ["instant", "low", "medium", "high"], index=2)
    stream_answer = st.checkbox("Stream answer", value=False)
    diffusing = st.checkbox("Diffusing mode (requires streaming)", value=False)
    reasoning_summary = st.checkbox("Return reasoning_summary", value=False)
    reasoning_summary_wait = st.checkbox("Wait for reasoning_summary", value=False)
    if diffusing and not stream_answer:
        st.info("Diffusing requires streaming. Enabling streaming automatically.")
        stream_answer = True
run = st.button("Run agent", type="primary")
if run:
    if not question.strip():
        st.warning("Enter a question.")
        st.stop()
    answer_placeholder = st.empty()  
    status_placeholder = st.empty()
    def _stream_cb(text: str, meta: Dict[str, Any]):
        answer_placeholder.markdown(text)
    with st.spinner("Running…"):
        status_placeholder.caption("Planning → searching → synthesizing…")
        out = asyncio.run(
            run_agent(
                question.strip(),
                n_queries,
                max_results,
                do_verify,
                reasoning_effort=reasoning_effort,
                stream_answer=stream_answer,
                diffusing=diffusing,
                reasoning_summary=reasoning_summary,
                reasoning_summary_wait=reasoning_summary_wait,
                stream_callback=_stream_cb if stream_answer else None,
            )
        )
    status_placeholder.empty()
    st.subheader("Answer")
    st.write(out["answer"])
    st.subheader("Timings (sec)")
    st.json(out["timings_sec"])
    with st.expander("Plan (queries / subquestions)"):
        st.json(out["plan"])
    with st.expander("Evidence (search results)"):
        st.json(out["evidence"])

De bovenstaande code definieert hoe de Streamlit-laag de functie run_agent() omzet in een interactieve onderzoekswerkflow. De gebruiker voert een vraag in, stuurt de breedte en diepte van de zoekopdracht aan en kan optioneel een verificatiepass inschakelen die niet-onderbouwde claims verwijdert. 

Een extra paneel “Mercury settings” toont modelknoppen zoals reasoning_effort, streaming output en diffusing-modus, die streaming vereist en de antwoord-placeholder ter plekke bijwerkt zodra er nieuwe chunks binnenkomen. 

Bij uitvoeren valideert de app de invoer, streamt gedeeltelijke output naar een placeholder en rendert vervolgens het definitieve antwoord samen met timings en uitklapbare debugweergaven voor het gegenereerde plan en het bewijspakket.

Wil je het zelf proberen? Sla de code op als app.py en start:

streamlit run app.py

Conclusie

In deze tutorial bouwden we een latentie-bewuste onderzoeksagent aangedreven door Mercury 2. Het systeem genereert een gestructureerd zoekplan voor een gebruikersvraag, voert vervolgens parallelle webretries uit, normaliseert resultaten tot een compact bewijsformaat en produceert een gefundeerd antwoord met citaties.

We hebben ook een optionele verificatiepass toegevoegd die het concept opnieuw checkt aan de hand van hetzelfde bewijs en niet-onderbouwde claims nuanceert. Dit eenvoudige Generate–Critique–Fix-patroon verbetert de feitelijke onderbouwing aanzienlijk met minimale extra latentie.

Naast de kernpijplijn stelt de applicatie Mercury 2’s runtime-instellingen bloot, waaronder redeneringsinspanning, streamingoutput, redeneringssamenvattingen en diffusing-modus. Om dit project verder uit te breiden, kun je:

  • De DuckDuckGo-scraper vervangen door een productie-zoek-API (Bing, SerpAPI, Brave)
  • Zoekresultaten of tussentijdse plannen cachen om herhaalde latentie te verminderen
  • Bewijs bewaren voor sessiegeheugen of meerbeurtonderzoek
  • Een samenvattingslaag toevoegen voor selectie van bewijs met hogere kwaliteit

Wil je meer leren over het gebruik van AI voor ontwikkelingstaken? Dan raad ik de cursus AI-Assisted Coding for Developers aan.

Mercury 2 FAQ’s

Wat maakt Mercury 2 anders dan traditionele LLM’s?

Mercury 2 gebruikt een diffusie-achtige, parallelle verfijningsmethode: het produceert een concept en verbetert dit in meerdere stappen. Dit maakt hogere throughput en betere prestaties mogelijk in pijplijnen met meerdere calls waar latentie zich opstapelt.

Wat is de diffusing-modus van Mercury 2?

De diffusing-modus streamt tussentijdse concepten terwijl het model zijn output verfijnt. In plaats van token-voor-token te typen, wordt de tekst ter plekke geleidelijk herschreven en verbeterd.

Waarom een verificatiepass opnemen?

De verificatiestap beoordeelt het concept opnieuw aan de hand van hetzelfde bewijs en verwijdert niet-onderbouwde claims. Dit verbetert de onderbouwing met slechts één extra modelcall.

Is de DuckDuckGo-zoekimplementatie productierijp?

Nee. De HTML-scrapingaanpak is gekozen vanwege de eenvoud en het ontbreken van API-sleutels, maar kan stukgaan als paginalayouts wijzigen en kan worden geratelimiteerd. Gebruik voor productie een stabiele zoek-API zoals Bing Web Search, Brave Search of SerpAPI.

Wat kost Mercury 2?

Mercury 2 is ontworpen voor workloads met hoge frequentie, met lage input-tokenkosten en korting op gecachte tokens. Nieuwe gebruikers ontvangen momenteel gratis tokens bij aanmelding, voldoende om deze tutorial te draaien en met de agent te experimenteren.

Aashi Dutt

Auteur

Aashi Dutt

Ik ben een Google Developers Expert in ML (Gen AI), een Kaggle 3x Expert en een Women Techmakers Ambassador met meer dan 3 jaar ervaring in tech. In 2020 heb ik een healthtech-startup mee opgericht en ik volg een master computer science aan Georgia Tech, met als specialisatie machine learning.

Onderwerpen