Conceptio is the document retrieval layer for AI agents: a search engine across a large live corpus of open-access documents: books, papers, standards, case law and public records. Every source is open access or public domain, every result links straight back to its origin, and every answer can carry license-aware access and agent-ready provenance.

What you get

• Search the full archive with keywords and directives
• Filter by language, source and PDF availability
• Cite & export in BibTeX, Markdown or JSON
• Connect agents via MCP or the CLI
• Save research to Zotero or Obsidian with provenance attached

Try it now

Head to Search and type a query. Sign in free (Google or email) to unlock your first 20 credits. Signing in also syncs your reading list across devices.

// Search in the web UI
$ open https://www.conceptio.app/search

The fastest way to use Conceptio from your own tools is the CLI. One command installs it:

pip install conceptio-search

Or run the MCP server directly without a global install via the official MCP registry:

uvx conceptio-search mcp

Then save your API key (one time: get it from your profile at conceptio.app after signing in):

conceptio auth <your-api-key>

Then verify it works:

conceptio --help
conceptio quota

Requirements

• Python 3.8+
• An internet connection (results stream from the archive)
• An API key for CLI and agent use; save one with conceptio auth (key from your profile). The browser trial needs a free sign-in (Google/email) so your 20-credit allowance follows your account.

Let's search for "zero trust", a real standards topic you'll find in the archive.

conceptio search "zero trust"

You'll get a list of matching documents, each with:

• Source badge (STD, PAPER, BOOK, …)
• Titled result with an author
• A snippet with your query highlighted
• A direct PDF link when one is available

Click any result to open the full detail view: eleven citation formats, a reader, and export options.

Conceptio supports both natural keywords and a few handy directives to narrow a query.

Keywords

Type one or more words. Multiple keywords work best for relevance.

neural networks
attention is all you need

Directives

Constrain a query with source:, lang: or category:. Directives can appear anywhere in the query and are stripped from the matched keywords. Values may be quoted to include spaces.

source:jstage llm
lang:it economia
category:"law & regulation" gdpr
src:eurlex "artificial intelligence act" lang:en

• source: / src:: restrict to one or more sources (repeatable)
• lang: / language:: restrict to a language (en, it, fr, de, es)
• category: / cat:: restrict to a category (e.g. "Law & Regulation", "Science & Medicine")
• license=commercial-ok: return only sources whose catalog metadata explicitly permits commercial use; unknown, open-access-only, and non-commercial declarations are excluded.

Tips

• Press / to focus the search bar
• Use Esc to clear the current query

Beyond directives, the search bar offers one-click filters.

Language

A segmented control filters results to a single language (or all). This maps to the lang: directive.

PDF only

Toggling PDF only hides results that don't have a direct PDF link, great when you want to download and keep the source.

Sources

The source chips let you probe the archive by publication: click a source to filter results to it, or clear all filters to reset.

Conceptio is MCP-native: any AI agent that speaks the Model Context Protocol can search the archive directly. Save an API key first (conceptio auth); the server reads the same local config.

Add the server

Put this in your tool's mcpServers config:

{
  "mcpServers": {
    "conceptio": {
      "command": "conceptio",
      "args": ["mcp"],
      "env": { "CONCEPTIO_API_KEY": "ckey_live_..." }
    }
  }
}

Or configure via uvx if you don't want a permanent installation:

{
  "mcpServers": {
    "conceptio": {
      "command": "uvx",
      "args": ["conceptio-search", "mcp"],
      "env": { "CONCEPTIO_API_KEY": "ckey_live_..." }
    }
  }
}

What agents get

• conceptio_search: search the corpus; conceptio_search_batch: queue 1–50 independent searches and poll the returned job handle
• conceptio_resolve, conceptio_get_document, conceptio_get_citation, and conceptio_download_pdf
• conceptio_connectors_send: save one document to Zotero or open a metadata-only Obsidian handoff; conceptio_connectors_send_all: Pro-only bulk Zotero save
• conceptio_graph_walk: walk the reference graph from a seed source_id: what it cites, what cites it, one or two hops either way, optionally filtered to the cites/updates kinds. Metadata-only, so it spends nothing. Use it when you need provenance (what cites this regulation two hops out) rather than a keyword match.
• Change watches are available through the authenticated HTTP API (/api/watch). A watch check can optionally push a bounded watch.changed JSON event to an HTTPS webhook signed with X-Conceptio-Signature: sha256=<HMAC-SHA256>; callbacks are never followed across redirects and webhook secrets are returned only when the watch is created.
• Machine-readable proof bundles on every result: sha256 content hash, publisher, authority score and its basis, license, retrieved timestamp, citations, and a trust envelope that separates the verified fields from the publisher's own voice and names the re-verification path
• Optional filters (language, source, category)

Machine-readable manifest: /mcp.json (tool schemas, one-line installs, rate-limit policy). OpenAPI contract: /api/openapi.json.

Trust envelope

Every proof bundle carries a trust block. It exists because a citation is only as good as the channel it arrived through, and most channels on the web are anonymous by default.

• verified: what Conceptio can prove about the retrieval: the sha256 of the source bytes (content_hash, with hash_algorithm), the canonical URL, the license, the access level, the publisher, the authority basis, the retrieved timestamp, and the version status (what superseded it and when)
• source_authored: the fields that carry the publisher's voice, unmodified: title, author, full text, the matched passage, the citations
• reverify: how to check a result without trusting us: fetch canonical_url and compare the sha256 of the bytes to content_hash

Provenance and integrity are the verified part; the text itself is the publisher's voice, carried unmodified. Peer-reviewed documents can contain instruction-shaped sentences (research papers quote payloads, court opinions quote threats), so nothing here claims the content is inert. What the envelope guarantees is attribution and byte integrity, and a path to prove both yourself.

No middleware. One key in ~/.conceptio/config.json, rotated from your profile any time. Wave goodbye to the "search by hand" era.

The CLI gives you the archive in your terminal. Requires an API key: conceptio auth once, then every command below works.

Commands

conceptio search "<query>"        # keyword search
conceptio search --batch queries.json --json  # queue 1–50 searches
conceptio search-job <job-id> --json         # poll once
conceptio save --to zotero <doc-id>
conceptio save --to obsidian <doc-id> --vault Research
conceptio save --to zotero --all-saved --ids saved-docs.json  # Pro only
conceptio resolve "RFC 2119"     # resolve an identifier to a document
conceptio download <id>           # download the direct PDF
conceptio cite <id> --format bibtex
conceptio mcp                     # run the MCP server

Flags

search: --batch QUERIES_JSON (queue 1–50, print the job handle) · --sync (with --batch: run 1–10 immediately, no queue) · --wait (with --batch: block until done) · -l/--limit (default 10) · --offset (default 0) · -c/--category · --lang (e.g. en, it, fr) · --license commercial-ok · --json · --markdown. resolve: -l/--limit · --json. download: -o/--output (default conceptio_<id>.pdf). cite: -f/--format (default from config, bibtex). save: --to zotero|obsidian (required) · --vault (Obsidian vault) · --all-saved + --ids IDS_JSON (bulk Zotero, Pro only). search-job: --wait · --json.

conceptio search "quantum" --lang en --json | jq .

The archive is a plain HTTP API, no SDK required. Programmatic access authenticates with X-Api-Key (key from your profile). Every endpoint is read-only except the Stripe/license flows. Base URL: https://www.conceptio.app.

Search

GET /api/search?q=zero+trust&language=en&sources=eurlex&limit=20&offset=0

• q: query string (directives supported)
• language: en, it, fr, de, es
• sources: comma-separated source ids
• limit / offset: pagination (limit 1–100, offset 0–1000; deeper offsets are rejected with 422: the product only pages shallowly, and deep offsets would burn shared read quota for no value)

Synchronous batch search

Issue one rate-limited request containing 1–10 independent searches. Each fresh subquery uses one search credit; deeper pages (offset > 0) remain free. The server validates the entire batch before dispatch, so an invalid batch consumes no credits and returns 422.

POST /api/search/batch

Content-Type: application/json
X-Api-Key: ckey_live_...

{
  "queries": [
    {"q": "zero trust", "limit": 5},
    {"q": "EU AI Act", "language": "en", "sort": "date"}
  ]
}

The response is { "count": N, "tier": "...", "queries": [...] }; each entry has the normal /api/search response shape, including results, proof bundles, and the account's remaining trial balance when applicable. Batches accept 1–10 items, query strings of 2–220 characters, limits of 1–100, non-negative offsets, and relevance or date sorting.

Asynchronous batch search

For larger agent workloads, queue 1–50 independent searches and poll the returned handle. Job creation is one rate-limited request; each fresh subquery uses one search credit when it runs, while polling is rate-limited but never spends a search credit. Jobs move through queued, running, and done states; they expire after a bounded retention window and return 410 when polled after expiry. Invalid batches return 422 before a job is created.

POST /api/search/jobs

{"queries": [{"q": "zero trust"}, {"q": "RFC 2119", "offset": 20}]}

GET /api/search/jobs/{id}

A completed poll returns {id, status, created_at, expires_at, result} where result uses the same {count, tier, queries} envelope as synchronous batch search. Job handles are account-scoped and must be polled with the same API key or signed-in identity that created them.

Identifier resolution

Resolve a known identifier (RFC number, DOI, arXiv ID, PubMed ID, NIST/FIPS/SP designation, EU regulation, UK statute, US statute, US regulation or legal citation, SEC accession/CIK/ticker, patent, procurement id, ISO/OGC/Khronos standard) straight to the document in the archive, or fall back to text search. Agents can hand a citation straight in and get the canonical record back, complete with ready-made citations and related documents.

GET /api/resolve?id=RFC+2119
GET /api/resolve?id=doi:10.1145/3290605.3300333
GET /api/resolve?id=2604.08499
GET /api/resolve?id=PMID+41961061
GET /api/resolve?id=PMC10601397
GET /api/resolve?id=NIST+FIPS+199
GET /api/resolve?id=w3c_digital-credentials
GET /api/resolve?id=GDPR
GET /api/resolve?id=2016%2F679
GET /api/resolve?id=Data+Protection+Act+2018
GET /api/resolve?id=410+U.S.+113
GET /api/resolve?id=18+F.4th+712
GET /api/resolve?id=20-5364
GET /api/resolve?id=ticker+TSLA
GET /api/resolve?id=US11704715B2
GET /api/resolve?id=OGC+WMS

• id: the identifier: RFC 2119, doi:10.xxxx/..., 2604.08499 (arXiv), PMID 41961061, NIST FIPS 199, PMC10601397 (PubMed Central), w3c_digital-credentials / TR/digital-credentials (W3C), GDPR / AI Act / 2016/679 (EU law), Data Protection Act 2018 / UK GDPR (UK statute), a US legal citation like 410 U.S. 113 / 18 F.4th 712 / 2021 VT 10, a US statute like 5 U.S.C. 552 / 42 USC § 1983, or a docket like 20-5364, or any free text
• limit: max results (default 10, max 50)
• Requires sign-in or an API key (X-Api-Key); a keyless request answers 401. Resolution fans out across every serving shard, so it is gated like the document family rather than left open.

Response includes kind (rfc, doi, arxiv, pmid, pmcid, nist, w3c, eu, uk, case for US citations/dockets, regulation for CFR parts like 40 CFR 1502, fr_document for Federal Register numbers like 2026-07364, statute for US Code sections like 5 U.S.C. 552, or null for text fallback), the canonical identifier, the matching documents, and per-result citations (BibTeX + APA) and related_documents (topically similar records).

In-document search & section extraction

Search inside one document's extracted full text. Beyond flat snippets, the response carries the whole matching sections (sections), so an agent can pull "the ITEM 1A block that mentions lithium" instead of a bare context window.

GET /api/document/{id}/search?q=lithium
GET /api/document/{id}/search?q=lithium&max_sections=3&max_chars=2000

• q: required, 1–200 characters
• max_sections: 1–20 (default 5): how many matching sections to return
• max_chars: 200–8000 (default 2000): per-section text cap

Each sections entry is {section, text, matches, offsets, truncated}: the section title (same splitter as /sections), its bounded text, the hit count, the absolute hit offsets, and whether the text was cut at max_chars. Access-aware: extraction derives from the served full text only, so metadata-only / license-restricted documents return full_text_available: false with empty sections, never a leak.

Content-hash resolution

Proof bundles carry content_hash: the sha256 of the document's source bytes. Resolve one straight back to the document record:

GET /api/hash/3b5d5c3712955042212316173ccf37bea9d0b9d1b5b5d5c37129550422123161

• sha256: 64 lowercase hex characters (else 422)
• Returns {sha256, document} where document has the same fields as a

/api/resolve result, including retrieval_options and the proof bundle.

• 404 when no indexed document carries that hash (the corpus only hashes

rows the extraction pipeline enriched). The lookup is an index read across serving shards, never a corpus scan.

• Requires sign-in or an API key (X-Api-Key); a keyless request answers

401, checked before the lookup touches a shard.

The authority score: what it is, and what it is not

Every proof bundle and document record carries authority_score and authority_basis. The score is a source-level seed, not a per-document judgement: it is assigned at ingest from a versioned maintenance table that maps the source's id to one of seven tiers, and every document from the same source carries the identical value by construction. authority_basis says why the number is what it is:

• "table": the source id matched a maintained pattern. Tiers: 0.9

statutes, official gazettes, courts of record, official registries of grants and public spending (eurlex, boe, usc, sec_edgar, google_patents); 0.85 case-law platforms, treaty bodies, official registries, security and standards organisations (bailii, canlii, hudoc, wipo, clinicaltrials, ietf); 0.8 law reviews and bibliographic indexes of record (pubmed, pmc); 0.75 multidisciplinary preprint servers (arxiv); 0.7 disciplinary preprints, scholarly indexes and repositories (biorxiv, openalex, zenodo); 0.6 public-domain literature (gutenberg).

• "default" (score exactly 0.5): the source is not classified by the

table. Read 0.5 as "unclassified", never as "average".

• "unscored" (score 0.0): the row predates the unified seed (2026-09-24);

reported honestly rather than dressed up as a low score.

Coverage: the table classifies over half of the corpus across 1M+ documents; the remaining entries carry the 0.5 default and say so via authority_basis: "default". No document carries 0.0; the pre-unification insert default was retired by the backfill.

The seed is deterministic and reproducible: the same source always yields the same score, which is what makes it usable in a compliance workflow. It is not a measure of precedential weight, quality, or truth: it asserts only that the document's source belongs to a maintained tier. The table lives in the ingestion pipeline and is applied identically at insert and at full-text enrichment; matching is token-aware, so a pattern like ted cannot match an unrelated id such as autogenerated.

Removed documents: tombstones

A document removed from the archive (e.g. a source row that no longer exists upstream) answers direct-access routes with 410 Gone and a structured tombstone instead of a bare 404, so a consumer holding a stale id learns what happened:

GET /api/document/999            # 410 Gone
GET /api/document/999/sections   # 410 Gone
GET /api/document/999/search     # 410 Gone
GET /api/document/999/proof      # 410 Gone

{
  "detail": {
    "error": "document_removed",
    "message": "This document was removed from the archive.",
    "tombstone": {
      "doc_id": 999, "source": "courtlistener", "source_id": "cl_3",
      "title": "Case cl_3", "reason": "pruned", "removed_at": "..."
    }
  }
}

A truly unknown id (never indexed, or removed before tombstones existed) still returns 404. The tombstone is a validity record, not a hard gate: a coordinator hiccup degrades back to 404, never a 500.

Other endpoints

POST /api/search/batch       # 1–10 searches in one request
POST /api/search/jobs        # queue 1–50 searches
GET /api/search/jobs/{id}    # poll an async search job
GET /api/health          # document count + last sync stamp
GET /api/openapi.json   # machine-readable OpenAPI spec for all endpoints
GET /api/sources         # full source catalog with counts
GET /api/source_list     # per-source freshness + counts
GET /api/categories      # category tree
GET /api/languages       # language distribution
GET /api/suggest?q=...   # source suggestions while typing
GET /api/document/{id}   # full document record (incl. section list)
GET /api/document/{id}/sections      # section structure over extracted full text
GET /api/document/{id}/search?q=...  # in-document search with snippets + whole matching sections
POST /api/document/{id}/verify   # ground a quoted span against served full text: {quote, spans?, case_sensitive?}, requires sign-in or X-Api-Key
GET /api/document/{id}/proof  # per-document evidence bundle: content_hash, license, citations, authority_score + authority_basis
GET /api/document/{id}/proof.pdf   # the same bundle as a downloadable PDF artifact; non-free tier required (a Pro session or a Dev/Enterprise key): 401 with no credentials, 403 on the free tier; a browser-tier API key is dev-gated here as on every other programmatic surface (the JSON bundle above needs only a session)
GET /api/hash/{sha256}    # resolve a content hash (proof content_hash) back to a document, requires sign-in or X-Api-Key
GET /api/graph/walk?seed=usc_42_1396a&hops=2&direction=out&kind=cites  # the typed compliance walk over the reference pair; nodes at their hop distance, edges as from-cites-to with relation kinds
GET /api/section/search?q=...&kind=risk_factors&source=sec_edgar  # cross-document section search, requires sign-in or X-Api-Key
GET /api/section/kinds                # supported section kinds (risk_factors, contracts, financials, ...)
GET /api/recent          # recently indexed documents
POST /api/watch          # create a change-detection watch: {target_type: doc|identifier|query, target, label?, limit?, webhook_url?, webhook_secret?}
POST /api/watch/{id}/check  # detect added/changed docs; push a signed event when configured
GET /api/watch           # list watches (fingerprint + change history)
GET /api/watch/{id}      # watch detail + event history
DELETE /api/watch/{id}   # remove a watch
GET /api/cite/{id}?format=bibtex   # apa, mla, chicago, ieee, harvard, ris, bluebook, oscola, iso690, ansiz39, bibtex
GET /api/models          # model-card corpus as JSON: ?q=, ?task=, ?license=, ?library= + keyset cursors
GET /api/models/{author}/{name}  # one model card as JSON; ?q= narrows it to matching sections

All catalog/read responses are JSON with CORS enabled. Stateful watch operations require a verified Firebase session or an account-bound API key; license-only and anonymous callers cannot create, enumerate, check, or delete watches.

Push watch delivery

Include webhook_url when creating a watch to receive a watch.changed POST whenever a subsequent check detects a changed fingerprint. The URL must be HTTPS and publicly routable; redirects, credentials, fragments, and private/non-global addresses are rejected. Supply a high-entropy webhook_secret, or omit it to have the API generate one. The secret is returned only in the creation response and is never included in list/detail responses. Verify the exact request body against X-Conceptio-Signature using HMAC-SHA256 before accepting the event. Callback failures are reported in the check response and do not roll back the recorded watch state.

The compliance walk

GET /api/graph/walk answers the question the corpus was built for: what does this document cite, what cites it, and how? It walks the stored reference pair (references/referenced_by on the proof bundle) as plain SQL: seed is a source_id, direction is out (what the seed cites), in (what cites it) or both, and hops is 1 or 2. Every node carries distance (hops from the seed) and every edge is canonical: from cites to, carrying its relation kinds: cites (the target is cited in the body) or updates (an amendment header names it). ?kind= (repeatable) follows only edges of the wanted kinds. Edges are the ones the walk traversed; a truncated: true response names a walk a measured cap stopped early (the worst live two-hop closure is 856 nodes, well inside them). 404 when the seed is not in the corpus. Metadata only, so this read never spends search credits.

Quote/span verification

POST /api/document/{id}/verify grounds a claimed quote against the document's served full text: prove "this document says X" before trusting a downstream claim. The body is {quote, spans?, case_sensitive?}; matching is verbatim by default (a strong claim), and case_sensitive: false opts into a weaker case-insensitive match reported as method: case_insensitive. The response returns every occurrence as {start, end, section} (offsets match /sections and in-document search exactly) plus, when you claim specific offsets, a per-span check that the bytes there hold the quote. Verification is access-aware: metadata-only documents fail closed with full_text_unavailable and are never verified against hidden text, and verification never consumes search credits. Each verdict carries the document's content_hash and a sha256 of the quote, so you can re-derive the claim from any served copy and chain it through GET /api/hash/{sha256}: a content-signed proof with no secret keys to manage.

Every document in Conceptio carries an access level that tells an agent exactly what it can do with the result before it tries. No guessing, no surprises.

The three access levels

• public_full_text: the full text is in the archive, inline, ready for retrieval and search_within. The source is public domain or openly licensed.
• open_access: the document is open access, but Conceptio holds metadata + an official link, not the extracted full text. The agent gets a direct link to the canonical source.
• metadata_only: Conceptio has the bibliographic record but no full text and no open link. The agent gets the citation and can seek the document elsewhere.

How it works in practice

When an agent calls /api/search, /api/search/batch, or /api/resolve, each result includes access_level; /api/resolve and document responses also advertise the retrieval_options capability list. An agent can:

// result from /api/resolve or /api/document/{id}
{
  "id": 304793,
  "title": "RFC 2119",
  "source": "ietf",
  "access_level": "public_full_text",
  "retrieval_options": ["full_text", "sections", "search_within", "cite", "proof"],
  ...
}

The agent knows immediately: it can call /api/document/304793 and get the full text, sections, and a proof bundle, no probing or 404s.

Full-text coverage vs. license entitlement

Access level describes the license: whether the source permits full-text hosting. Whether Conceptio actually holds the extracted full text is a separate dimension. The Source catalog page and the /api/sources endpoint both show full_text_count alongside access_level, so an agent can tell:

• usc: access_level=public_full_text (US Code is public), but full_text_count=0 (extraction pipeline hasn't run on it yet) → metadata + official link only, for now
• google_patents: access_level=public_full_text, full_text_count=740 → full text is live, search_within works
• crossref: access_level=open_access, full_text_count=0 → official link only, by design (we don't host publisher PDFs)

Conceptio is designed for fast, reliable access across web and machine callers. To keep the open-access archive sustainable and protect against abusive scrapers, requests are tiered and rate-limited.

Tier limits

• Pro tier (€9.99/mo): 60 requests/min, plus a 1,000 credits/month quota (resetting on the first day of each month at 00:00 UTC). Ideal for individual researchers and anyone reading primary sources in the browser.
• Dev tier (€19.99/mo): 60 requests/min, plus a 3,500 credits/month quota. The agent tier: full MCP server, REST API, and CLI access, batch/jobs, and proof bundles as machine-readable JSON.
• Enterprise tier: 300 requests/min (or custom concurrency) with organization-wide uncapped search allowances and dedicated shard routing.
• Free / Public tier: 60 requests/min per account with a 20-credit lifetime browser trial. Catalog, source, and document metadata endpoints stay browsable without signing in; search and full-text reads require a free sign-in with a confirmed email address and spend one of those 20 credits each, including cross-document section search. The confirmation (one link at signup) is what keeps disposable batch accounts out of the shared trial. Free API keys are refused on programmatic endpoints (403 + upgrade hint); agents require Dev.

How rate limits & quotas work

• Request pacing: requests spaced at a steady cadence enjoy uninterrupted throughput. If bursts exceed rate thresholds, the API returns an HTTP 429 with a Retry-After header indicating when to resume. The official CLI and MCP server handle request pacing and retries automatically in the background.
• Monthly credit quota (Pro/Dev): fresh queries (/api/search with offset=0), cross-document section search, and full-text document reads (/api/document/{id}, in-document search, and proof passages carrying served text) consume from your monthly budget (1,000 on Pro, 3,500 on Dev). Paginating deeper into existing results (offset > 0), metadata-only reads, section listings, verification, and exporting citations never consume search credits. Your balance resets on the first day of each month at 00:00 UTC.
• Sliding per-minute window: standard sliding 60-second window across all endpoints.

# Example: simple request pacing with retry support
import time, requests

for q in queries:
    resp = requests.get(
        f"https://www.conceptio.app/api/search?q={q}",
        headers={"X-Api-Key": "ckey_live_..."}
    )
    if resp.status_code == 429:
        retry_after = int(resp.headers.get("Retry-After", 2))
        time.sleep(retry_after)
        resp = requests.get(
            f"https://www.conceptio.app/api/search?q={q}",
            headers={"X-Api-Key": "ckey_live_..."}
        )
    data = resp.json()
    time.sleep(1.0)  # steady cadence

For agents

If you're building an automated pipeline, use the MCP server (conceptio mcp) or CLI (conceptio search), both automatically manage authentication, backoff retries, and formatting. You can check your remaining monthly credit budget at any time with conceptio quota.

Connector saves are separate from search credits. Every signed-in account gets a shared three-send connector trial across Zotero and Obsidian; successful saves consume one send, repeated saves for the same account/document are idempotent, and failed delivery does not consume the trial. Pro, institutional, and license access bypasses the trial. Anonymous users receive 401 and are prompted to sign in.

Zotero

Connect a Zotero Web API key and user ID from Profile. The key is verified before storage, retained server-side only, and shown only as its final four characters. Single-document sends use POST /api/connectors/zotero/send; bulk export of saved documents uses POST /api/connectors/zotero/send-all and is a Pro capability. The exported Zotero item includes citation metadata, a canonical document URL, and provenance in its extra field. The same server-owned route is available to CLI (conceptio save --to zotero <doc-id>) and MCP; bulk saves are Pro-only.

Obsidian

Obsidian saves from the browser web app are metadata-only. The browser opens a sanitized obsidian://new URI containing title, authors, year, abstract excerpt, citation, canonical URL, hash, license, and a backlink; it does not copy source bytes. The server authorizes before launch and logs a successful handoff with POST /api/connectors/obsidian/authorize and POST /api/connectors/obsidian/log. If Obsidian is not installed or does not open, the UI provides a dismissible install hint.

For researchers working primarily inside Obsidian, the Conceptio for Obsidian native vault plugin (conceptio-obsidian) provides a full in-vault client (suggest-modal search, DOI/PMID/RFC resolution, 11 citation formats, note creation with proof links, vault reading lists, and Obsidian 1.12.2+ CLI integration); see Obsidian plugin.

Free-tier attribution

Free-tier search responses add an attribution object with {text, url}. It is additive metadata for API, CLI, and MCP consumers and does not alter formal citation strings or proof bundles. The same object is present on synchronous batch, asynchronous job results, and identifier-resolution responses.

Conceptio exports citations in eleven citation formats and results in three structured formats.

Citations (11 formats)

• BibTeX: LaTeX, Overleaf, and reference managers (Zotero, JabRef)
• APA 7 · MLA 9 · Chicago (Author-Date): standard academic and publishing styles
• IEEE · Harvard: engineering, computer science, and social sciences
• RIS: EndNote, Mendeley, and Citavi interchange
• Bluebook · OSCOLA: US and Commonwealth legal and statutory citations
• ISO 690 · ANSI/NISO Z39.29: international and US bibliographic standards

Results export

• BibTeX (.bib): complete bibliography ready for LaTeX and reference libraries
• Markdown (.md): clean, structured document notes formatted for Obsidian, Notion, and Logseq
• JSON (.json): raw structured record payloads for scripts, pipelines, and agents

Use the Export button on the results header or copy citations directly from the document view.

Bookmark a result to add it to your reading list. It's saved locally by default, and synced across devices when you sign in.

Save

Click the bookmark icon on any result card to toggle it in your list.

Manage

Visit the Saved view to see everything you've bookmarked, open the reader, or remove items.

Your list is private to you, never shared or sold.

Conceptio is built for agents, developers, and researchers who need structured access to open documents. Here's how people use it.

Agent pipelines

An AI agent that needs to answer questions about regulations, standards, or case law can search Conceptio, retrieve full text with sections, cite the source with a proof bundle, and watch for changes, all without leaving the MCP context.

# Agent flow: resolve → get → cite
conceptio resolve "GDPR"           # find the regulation in the archive
conceptio search "data protection" --json   # structured results with proof bundles
conceptio cite 304793 --format bibtex       # ready-made citation

Legal research

Search across EU regulations (EUR-Lex), UK statutes, US Code, eCFR, Federal Register, and landmark SCOTUS opinions. Use /api/resolve to jump straight to a cited statute or regulation by its citation form.

GET /api/resolve?id=2016/679        # EU GDPR
GET /api/resolve?id=42 USC 1983  # US Code section
GET /api/resolve?id=40 CFR 1502  # CFR part

Standards lookup

Find IETF RFCs, W3C specifications, NIST/FIPS publications, and standards from ECMA, OASIS, Khronos, OGC, and ISO/IEC JTC 1, all with full text when available.

GET /api/resolve?id=RFC 2119
GET /api/resolve?id=NIST FIPS 199
GET /api/resolve?id=w3c_digital-credentials

Contract analysis

SEC material contracts (Exhibit 10.x) are indexed with clause-level section kinds: search across all contracts for specific clause types like indemnification, termination, or change-of-control.

GET /api/section/search?kind=indemnification
GET /api/section/search?kind=governing_law

Patent research

US patents from Google Patents are indexed with full text, claims, and abstracts. Search within claims across the patent corpus.

GET /api/section/search?kind=patent_claims
GET /api/resolve?id=US11704715B2

Change monitoring

Watch a document, identifier, or query and detect when new or changed documents are indexed. Pull-driven: an agent or cron calls check periodically.

POST /api/watch   # {"target_type": "query", "target": "data protection", "label": "DP updates"}
POST /api/watch/1/check   # diff since last snapshot

Do I need an account?

For searching and full-text reading, yes, a free one. Your first 20 credits are on us; sign-in (Google or email) lets the allowance follow your account instead of your browser. You can browse the catalog and document metadata without an account. Agents and the CLI use an API key you mint after signing in.

Is a credit card required?

No. Signing up for the free plan never asks for a card. Only optional Pro upgrades bill.

Is search really free?

Yes, with one honest caveat. The web app gives every signed-in account a one-time allowance of 20 credits (the server enforces the balance, so it follows you across devices and browsers). Each fresh search and each full-text document read spends one credit; deeper result pages, metadata-only reads, section listings, verification, and citations never do. Searching and full-text reading pause when that allowance is used up; you can still browse the archive, its metadata, and use the tools. Signing in with Pro (€9.99/mo) or redeeming a license key removes the gate entirely.

Raw HTTP searches and full-text document reads require a free sign-in in the web app; the CLI and MCP server always authenticate with an API key, and free-plan keys are refused on programmatic endpoints with an upgrade hint; agents require the Dev plan.

Do you sell my data?

Never. Conceptio collects no personal data in standard use. The web app serves no advertising and no tracking scripts, and the MCP server serves none either: no sponsored slots, no ad requests, and no query text is ever sent to an advertising partner.

Where does the content come from?

Every source is open access or public domain: books, papers, standards, case law and public records.

Can my AI agent use Conceptio?

Yes, with an API key: conceptio auth once, then via MCP or the CLI. See the MCP and CLI sections.

Conceptio connects directly into the tools and editors you already use. Every extension rides the official archive API or the conceptio CLI core, bringing fast search, inline citations, and verifiable proof bundles straight to your desktop.

At a glance

• Neovim: Native Lua plugin (conceptio.nvim) with Telescope picker integration and instant citation pasting.
• Obsidian: Native vault plugin (conceptio-obsidian) to insert citations, generate research notes with YAML frontmatter, and sync reading lists into your vault.
• Zotero: Web API connector for 1-click document saves and bulk library exports with canonical origin links.

conceptio.nvim brings the open knowledge archive to Neovim buffers.

Installation

Using lazy.nvim:

{
  "0x923041-dotcom/conceptio.nvim",
  dependencies = { "nvim-lua/plenary.nvim", "nvim-telescope/telescope.nvim" },
  opts = {
    api_key = os.getenv("CONCEPTIO_API_KEY"),
    default_cite_format = "bibtex",
  },
  keys = {
    { "<leader>cs", "<cmd>ConceptioSearch<cr>", desc = "Conceptio Search" },
    { "<leader>ci", "<cmd>ConceptioInsertCitation<cr>", desc = "Insert Citation" },
  },
}

Features

• Fast search via Telescope picker.
• Instant citation insertion at the cursor across all 11 supported bibliographic formats.
• Offline contract tests ensure compatibility with conceptio-cli.

The conceptio-obsidian plugin provides a full-featured research client directly inside your Obsidian vault. It acts as a sleek presenter over the public conceptio CLI (pip install -U conceptio-search), sharing credentials (conceptio auth, $CONCEPTIO_API_KEY, or in-plugin settings), retries, and rate limits without duplicating logic.

Installation

Install from the latest release: manifest.json, main.js, and styles.css into .obsidian/plugins/conceptio/, or point BRAT at the repository.

Requires desktop Obsidian (1.4+) and the conceptio CLI (0.3.1+) on your system PATH.

Features

• Archive search modal & ribbon: Query the Conceptio Open Knowledge Archive from the command palette (Conceptio: Search the archive) or ribbon icon, with full support for directives (source:, lang:, category:, license:commercial-ok).
• Universal identifier resolution: Directly resolve DOIs (doi:10.1145/...), PubMed IDs (PMID 41961061), RFCs (RFC 2119), arXiv identifiers (2604.08499), court cases (410 U.S. 113), and technical standards (NIST FIPS 199) with immediate navigation or picker options.
• Citation insertion (11 formats): Insert citations at cursor in APA, BibTeX, Chicago, Harvard, IEEE, MLA, Nature, Vancouver, OSCOLA, Bluebook, or ISO 690. BibTeX inserted into LaTeX preserves verbatim syntax.
• Document note generation: Creates a clean, dedicated note in your vault folder (default Conceptio/) with full YAML frontmatter (title, author, year, source, license, access, conceptio_id, conceptio_url, source_url, pdf_url, accessed, tags), proof links, and a tracking comment marker (<!-- conceptio:doc:{id} -->) preventing overwriting existing notes.
• Append cited sections: Appends a selected passage and its proof metadata to the active note.
• Vault reading list: Bookmark documents directly into <vault>/.obsidian/plugins/conceptio/data.json (completely local and private to your vault). Export anytime to Conceptio Reading List.md as an interactive checkbox list with live backlinks.
• Account & quota meter: Inspect tier, remaining credits, and quota reset date directly in-vault via conceptio quota --json.
• Obsidian CLI integration (Obsidian 1.12.2+): Exposes 11 native terminal commands in the official obsidian CLI (e.g. obsidian conceptio search query="...", obsidian conceptio cite id=..., obsidian conceptio note id=..., obsidian conceptio reading-list, and obsidian conceptio:quota), enabling automated scripts and shell pipelines to query the archive and drive vault notes.

Conceptio serves two corpora. The archive is documents. The second is model cards: Hugging Face model cards mirrored for structured reading, so you can check a license, a task, or, where the card's text has been mirrored, what the model's own card says without leaving the archive. See them in the app at Models → browse: /models 301s there and has no page of its own.

A card is not a document: cards live in their own corpus, they are not counted in the archive's document totals, and a card's text is the card its author published.

• GET /models: a 301 to /models/browse with the query string intact, bare or parameterised: there is no page at this URL (since 2026-09-22), and the app does the filtering and the paging.
• GET /models/{author}/{name}: one card: license, task, tags, engagement, and the card's own text where it could be fetched openly. Add ?q= to narrow that card to the sections mentioning every term; the page states how many of its sections it is showing.
• GET /api/models: the same listing as JSON: ?q=, ?task=, ?license=, ?library=, both keyset cursors, the facet blocks, and a filters / ignored pair that keeps "did nothing" apart from "matched everything".
• GET /api/models/{author}/{name}: one card as JSON, with ?q= narrowing it to the sections that match.
• GET /data/models.jsonl: the whole catalog in one fetch: one card per line, metadata-only (the same fields /api/models returns), gzipped when your client asks for it. GET /data/models.manifest.json states its row count, its columns and its fields, so you can check the size without downloading it.

Reading cards needs no account and no plan, and a free API key is accepted here too: this corpus is mirrored public metadata and reading it spends nothing. The pricing lock covers the surfaces that spend.

Bulk dumps

GET /data/models.jsonl           # the whole model-card corpus, one card per line (metadata-only)
GET /data/models.manifest.json   # its row count, columns and fields
GET /data/corpus.jsonl           # the document archive, nightly metadata JSONL (redirects to the published gzip)

The document dump is refreshed daily; the model-card dump is rendered when you ask for it, so it is current to the minute. Both are metadata-only, with no full text, and nothing beyond what the pages already serve free.

Conceptio indexes hundreds of sources across papers, law, standards, books, contracts, patents and filings. Every source in the catalog is open access or public domain. Conceptio hosts full text only where the license permits; for paywalled publications it carries the citation, the access level, and a direct link to the official source, never the text itself.

Where to see the catalog

• Web: the Source catalog page lists every source with its category, document count, license, and access level.
• API: GET /api/sources returns machine-readable source records with per-source counts and full-text coverage; GET /api/source_list serves the compact per-source catalog the source chips use.
• Agent: GET /api/sources returns the same catalog machine-readably (the CLI has no sources command).

GET /api/sources
# source_id, name, category, license, access_level, count, full_text_count

Coverage vs. entitlement

access_level says what the license permits; full_text_count says what Conceptio actually holds. A source can be public_full_text by license but hold zero extracted rows yet (the extraction pipeline runs continuously), so agents should check full_text_count > 0 before assuming search_within works. The reader degrades content gracefully when full text is absent.

Querying a specific source

// restrict a search to one source (repeatable)
GET /api/search?q=gdpr&source=eurlex
GET /api/search?q=zero+trust&sources=ietf,nist

// get a source catalog page (server-rendered, indexable)
GET /source/{source_id}

Per-source filtering

Each source catalog page (/source/nist, /source/eurlex, …) is a server-rendered, indexable landing that lists sample documents and scoped search: the entry point for source-specific queries like "NIST publications" or "EUR-Lex full-text search".

Conceptio indexes third-party open-access documents; it does not host copyrighted content. Full policies live on the Legal page; this section summarizes the points most relevant to agents and automated consumers.

Data minimization

Conceptio collects no personal data in standard use: search queries are not logged or profiled, and no advertising scripts are served. The only analytics is our own consent-gated, cookieless product analytics (PostHog, EU cloud): until a visitor accepts, no analytics code runs at all, and it never receives search text or account identifiers. Accounts (used only to gate Pro/Enterprise access) store the sign-in email in our meta database, needed to bind a subscription, license, or API-key ownership to you; nothing else about you is collected. No advertising surface exists anywhere in the product, web or MCP (see Do you sell my data?).

License keys & authentication

Signing in (Google or email) stores your sign-in email and its domain in our account database, used only to resolve tier and key ownership; we do not store your picture or further Google data. Searching consumes the free allowance or a Pro subscription; browsing the catalog needs no account. License keys must not be shared, resold, or redistributed. For machine credentials, use an API key instead: scoped, revocable, no human sign-in.

For machine credentials (agents, scripts, CI pipelines), an API key is the cleaner path than a license key: it is scoped, revocable, and does not tie requests to a human sign-in.

• Format: ckey_live_<32 hex chars>: distinct from CONCEPTIO- license keys.
• Authenticate: send it as the X-Api-Key header on any API call. No Firebase token needed.
• Get one: any signed-in account can create a key under Profile → API key (self-serve, one click). Free- and Pro-plan keys resolve to their tier and are refused on programmatic endpoints with an upgrade hint (agents require the Dev plan; Pro is the browser tier); Dev and Enterprise keys are unlimited. Keys are also accepted by the CLI (conceptio auth <key> auto-detects the type).
• Privacy: only a SHA-256 hash of the key is stored server-side. The plaintext is shown exactly once, at creation; the response is the only copy. If you lose it, revoke and create a new one.
• Revoke: Profile → API key → Revoke, or DELETE /api/keys/{id}. Revocation is instant: requests with a revoked key fall back to anonymous limits immediately.
• Scope: keys are bound to the email that created them and cannot be used to manage anything beyond that account's own keys.

# Use an API key from any agent or script
curl -H "X-Api-Key: ckey_live_..." "https://www.conceptio.app/api/search?q=quantum+annealing"

License keys must not be shared, resold, or redistributed; the same applies to API keys: revoke rather than share.

Acceptable use for agents

• Automated consumption is welcome via the MCP server (conceptio mcp) or the REST API.
• Respect rate limits: Pro tier is 60 req/min (1,000 credits/month); Dev is 60 req/min (3,500 credits/month); Enterprise is 300 req/min; anonymous traffic is capped per IP at 60 req/min. Respect HTTP 429 and Retry-After.
• No scraping, API abuse, or rate-limit circumvention. Enterprise licenses are bound to the licensed organization.

Content accuracy

Conceptio does not guarantee the accuracy or completeness of third-party content. Always verify against the canonical source (each result carries a direct source_url) before relying on it for professional, legal, or medical purposes.

Rights & GDPR

You may request access to, correction of, or deletion of your data at any time. Because Conceptio holds minimal data, deletion is typically processed immediately. See the full Privacy Policy and Terms of Service.