---
source_url: "https://pypi.org/project/browseaidev/0.2.1/?utm_source=openai"
title: browseaidev · PyPI
mirrored_at: 2026-08-05T13:03:04.891Z
host: pypi.org
cited_in_42a: true
mirror_canonical: "https://index.42a.ai/pypi.org/project/browseaidev/0.2.1/index__q__utm_source_openai"
---

> **Original source:** https://pypi.org/project/browseaidev/0.2.1/?utm_source=openai

**Reliable research infrastructure for AI agents.** Python SDK for [BrowseAI Dev](https://browseai.dev/) — the research layer for LangChain, CrewAI, and custom agent pipelines.

## Install

pip install browseaidev

## Quick Start

from browseaidev import BrowseAIDev

client \= BrowseAIDev(api\_key\="bai\_xxx")

\# Research with citations
result \= client.ask("What is quantum computing?")
print(result.answer)
print(f"Confidence: {result.confidence:.0%}")
for source in result.sources:
    print(f"  - {source.title}: {source.url}")

\# Thorough mode — auto-retries if confidence < 60%
thorough \= client.ask("What is quantum computing?", depth\="thorough")

\# Deep mode — multi-step agentic research with iterative gap analysis (requires BAI key + sign-in)
\# Runs think→search→extract→evaluate cycles (up to 4 steps), 3x quota cost
deep \= client.ask("Compare CRISPR approaches", depth\="deep")
for step in deep.reasoning\_steps or \[\]:
    print(f"  Step {step.step}: {step.query} ({step.confidence:.0%})")

\# Web search
results \= client.search("latest AI news", limit\=5)

\# Page extraction
page \= client.open("https://example.com")

\# Structured extraction from a URL
extract \= client.extract("https://example.com", query\="pricing info")

\# Compare raw LLM vs evidence-backed
compare \= client.compare("Is Python faster than Rust?")

\# Clarity — prompt mode (get enhanced prompts for your own LLM)
prompts \= client.clarity("Write a blog post about quantum computing", mode\="prompt")
print(prompts.system\_prompt)  \# Anti-hallucination system prompt
print(prompts.user\_prompt)    \# Rewritten user prompt with grounding cues
print(prompts.techniques)     \# Which techniques were selected

\# Clarity — answer mode (LLM answers with reduced hallucinations, no internet)
clarity \= client.clarity("Write a blog post about quantum computing", mode\="answer")
print(clarity.answer)         \# LLM answer with reduced hallucinations
print(clarity.claims)         \# Extracted claims (origin: "llm")
print(clarity.confidence)     \# Confidence score

\# Clarity — verified mode (LLM + web fusion for maximum accuracy)
verified \= client.clarity("Explain CRISPR gene editing", mode\="verified")
print(verified.answer)        \# Fused answer (best of LLM + web sources)
print(verified.claims)        \# Claims with origin: "confirmed", "llm", or "source"
print(verified.sources)       \# Web sources used for verification

\# Submit feedback to improve accuracy
client.feedback(result\_id\=result.share\_id, rating\="good")

## Async

from browseaidev import AsyncBrowseAIDev

async with AsyncBrowseAIDev(api\_key\="bai\_xxx") as client:
    result \= await client.ask("What is quantum computing?")
    \# Thorough mode works with async too
    thorough \= await client.ask("What is quantum computing?", depth\="thorough")
    \# Deep mode — multi-step agentic research (requires BAI key + sign-in, 3x quota cost)
    deep \= await client.ask("Complex research question", depth\="deep")

## Streaming (REST API)

For real-time progress events, use the streaming endpoint directly:

import httpx

with httpx.stream("POST", "https://browseai.dev/api/browse/answer/stream",
    json\={"query": "What is quantum computing?"},
    headers\={"X-Tavily-Key": "tvly-xxx", "X-OpenRouter-Key": "sk-or-xxx"}
) as response:
    for line in response.iter\_lines():
        if line.startswith("data: "):
            print(line\[6:\])

Events: `trace` (progress), `sources` (discovered early), `token` (streamed answer text), `result` (final answer), `done`.

## Research Memory (Sessions)

Persistent research sessions that accumulate knowledge across multiple queries. Later queries recall prior knowledge — faster, cheaper, more coherent.

> **Sessions require a BrowseAI Dev API key** (`api_key="bai_xxx"`) for identity and ownership. BYOK clients (`tavily_key`/`openrouter_key` only) can use search/answer but cannot create or access sessions. Get a free API key at [browseai.dev/dashboard](https://browseai.dev/dashboard).

from browseaidev import BrowseAIDev

client \= BrowseAIDev(api\_key\="bai\_xxx")

\# Create a session
session \= client.session("wasm-research")

\# Each query builds on previous knowledge
r1 \= session.ask("What is WebAssembly?")
r2 \= session.ask("How does WASM compare to JavaScript performance?")
\# ^ r2 recalls WASM knowledge from r1, only searches for JS perf

\# Query accumulated knowledge without new searches
recalled \= session.recall("WASM")
for entry in recalled.entries:
    print(f"  {entry.claim} (from: {entry.origin\_query})")

\# Export all knowledge
knowledge \= session.knowledge()

\# Delete a session
session.delete()

\# List all your sessions
sessions \= client.list\_sessions()

\# Resume an existing session by ID
session \= client.get\_session("session-id-here")

\# Share with other agents
share \= session.share()
print(share.url)  \# https://browseai.dev/session/share/abc123def456

\# Another agent forks and continues the research
forked \= client.fork\_session(share.share\_id)

Async sessions work the same way:

async with AsyncBrowseAIDev(api\_key\="bai\_xxx") as client:
    session \= await client.session("my-project")
    r1 \= await session.ask("What is WASM?")
    r2 \= await session.ask("WASM vs JS?")

    \# Share and fork work async too
    share \= await session.share()
    forked \= await client.fork\_session(share.share\_id)

## Premium Features (with API Key)

Users with a BrowseAI Dev API key (`bai_xxx`) get enhanced verification:

-   **Neural cross-encoder re-ranking** — search results re-scored by semantic query-document relevance
-   **NLI semantic reranking** — evidence matched by meaning, not just keywords
-   **Multi-provider search** — parallel search across multiple sources for broader coverage
-   **Multi-pass consistency** — claims cross-checked across independent extraction passes (in thorough mode)
-   **Deep reasoning mode** — premium multi-step agentic research with iterative think-search-extract-evaluate cycles, gap analysis, and cross-step claim merging (up to 4 steps, targets 0.85 confidence, 3x quota cost, 100 deep queries/day). Falls back to thorough when quota is exhausted
-   **Token streaming** — per-token answer delivery via SSE for real-time UI
-   **Research Sessions** — persistent memory across queries

Free BAI key users get a generous daily quota (100 premium queries/day, or ~33 deep queries/day at 3x cost each). When exceeded, queries gracefully fall back to BM25 keyword verification (deep falls back to thorough) — still works, just basic matching. Quota resets every 24 hours. Check `client.last_quota` after any API call for current usage.

**No account needed** — BYOK works out of the box with no signup, no limits, and BM25 keyword verification. Sign in at [browseai.dev](https://browseai.dev/) for a free BAI key to unlock premium features.

## Contradictions

Detect conflicts across sources on controversial topics:

result \= client.ask("Is coffee good for your health?", depth\="thorough")
if result.contradictions:
    for c in result.contradictions:
        print(f"Conflict on '{c.topic}':")
        print(f"  A: {c.claim\_a}")
        print(f"  B: {c.claim\_b}")

## Enterprise Search Providers

Use your own data sources instead of — or alongside — public web search. Supports `elasticsearch`, `confluence`, and `custom` endpoints with optional `data_retention="none"` for compliance.

from browseaidev.models import SearchProviderConfig

\# Using the typed model (snake\_case fields)
provider \= SearchProviderConfig(
    type\="elasticsearch",
    endpoint\="https://es.company.com/kb/\_search",
    auth\_header\="Bearer token",
    index\="docs",
)
result \= client.ask("What is our refund policy?", search\_provider\=provider)

\# Or pass a plain dict (camelCase keys, sent directly to API)
result \= client.ask("What is our refund policy?", search\_provider\={
    "type": "elasticsearch",
    "endpoint": "https://es.company.com/kb/\_search",
    "authHeader": "Bearer token",
    "index": "docs",
})

\# Confluence
result \= client.ask("PCI compliance?", search\_provider\={
    "type": "confluence",
    "endpoint": "https://company.atlassian.net/wiki/rest/api",
    "authHeader": "Basic base64-creds",
    "spaceKey": "ENG",
})

\# Zero data retention (compliance mode — nothing stored, cached, or logged)
result \= client.ask("Patient protocols", search\_provider\=SearchProviderConfig(
    type\="elasticsearch",
    endpoint\="https://es.hipaa.company.com/medical/\_search",
    auth\_header\="Bearer token",
    data\_retention\="none",
))

## BYOK (Bring Your Own Keys)

No signup required — just pass your own keys:

client \= BrowseAIDev(tavily\_key\="tvly-xxx", openrouter\_key\="sk-or-xxx")

## Framework Integrations

### LangChain

pip install langchain-browseaidev

from langchain\_browseaidev import BrowseAIDevAnswerTool, BrowseAIDevSearchTool

tools \= \[BrowseAIDevAnswerTool(api\_key\="bai\_xxx")\]

### CrewAI

pip install crewai-browseaidev

from crewai\_browseaidev import BrowseAIDevAnswerTool

researcher \= Agent(tools\=\[BrowseAIDevAnswerTool(api\_key\="bai\_xxx")\])

### LlamaIndex

pip install llamaindex-browseaidev

from llamaindex\_browseaidev import BrowseAIDevAnswerTool

answer\_tool \= BrowseAIDevAnswerTool(api\_key\="bai\_xxx")