veroq 1.0.0__tar.gz

veroq-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+.env
+.env.*
+*.whl
+*.tar.gz

veroq-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VEROQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

veroq-1.0.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: veroq
+Version: 1.0.0
+Summary: VEROQ Python SDK — verified intelligence for AI agents. The truth protocol for agentic AI.
+Project-URL: Homepage, https://veroq.ai
+Project-URL: Documentation, https://veroq.ai/docs
+Project-URL: Repository, https://github.com/veroq/veroq-python
+Project-URL: Bug Tracker, https://github.com/veroq/veroq-python/issues
+Project-URL: Changelog, https://veroq.ai/docs/changelog
+Author-email: VEROQ <dev@veroq.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,api,financial,intelligence,nlp,sdk,truth,verified,veroq
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.20
+Provides-Extra: async
+Requires-Dist: httpx>=0.24; extra == 'async'
+Description-Content-Type: text/markdown
+
+# veroq
+
+VEROQ Python SDK -- verified intelligence for AI agents. The truth protocol for agentic AI.
+
+> **Migrating from `polaris-news`?** This is the official successor. All class names and env vars are backwards compatible. Just change your import from `polaris_news` to `veroq`.
+
+## Installation
+
+```bash
+pip install veroq
+```
+
+## Quick Start
+
+### Universal Agent Connector (recommended)
+
+```python
+from veroq import Agent
+
+agent = Agent()  # reads VEROQ_API_KEY (or POLARIS_API_KEY) from env
+result = agent.ask("What's happening with NVDA?")
+print(result.summary)
+
+# Full cross-reference -- everything about a ticker in one call
+full = agent.full("AAPL")
+print(full.price, full.technicals, full.earnings)
+
+# Subscribe to real-time events
+for event in agent.subscribe(tickers=["NVDA", "AAPL"], events=["brief"]):
+    print(event.type, event.ticker, event.data)
+```
+
+### Authenticate via CLI
+
+```bash
+veroq login    # opens GitHub in your browser -- API key saved automatically
+veroq whoami   # check your auth status
+veroq logout   # remove saved credentials
+```
+
+### Full Client
+
+```python
+from veroq import VeroqClient
+
+client = VeroqClient()  # auto-reads saved credentials
+feed = client.feed(category="technology", limit=10)
+for brief in feed.briefs:
+    print(brief.headline)
+```
+
+You can also pass a key explicitly or set the `VEROQ_API_KEY` environment variable. For backwards compatibility, `POLARIS_API_KEY` is also supported.
+
+## Backwards Compatibility
+
+If you are migrating from `polaris-news`, the following aliases are available:
+
+```python
+from veroq import PolarisClient  # alias for VeroqClient
+from veroq import PolarisError   # alias for VeroqError
+```
+
+Both `VEROQ_API_KEY` and `POLARIS_API_KEY` environment variables are supported. Credentials from both `~/.veroq/credentials` and `~/.polaris/credentials` are read.
+
+## Methods
+
+| Method | Description |
+|--------|-------------|
+| `feed(category?, limit?, page?, per_page?, min_confidence?)` | Get the news feed |
+| `brief(brief_id, include_full_text?)` | Get a single brief by ID |
+| `search(query, category?, page?, per_page?, sort?, min_confidence?, from_date?, to_date?, entity?, sentiment?)` | Search briefs |
+| `generate(topic, category?)` | Generate a brief on a topic |
+| `entities(q?, type?, limit?)` | List entities |
+| `entity_briefs(name, role?, limit?, offset?)` | Get briefs for an entity |
+| `trending_entities(limit?)` | Get trending entities |
+| `similar(brief_id, limit?)` | Get similar briefs |
+| `clusters(period?, limit?)` | Get brief clusters |
+| `data(entity?, type?, limit?)` | Get structured data points |
+| `agent_feed(category?, tags?, limit?, min_confidence?)` | Get agent-optimized feed |
+| `compare_sources(brief_id)` | Compare sources for a brief |
+| `trending(period?, limit?)` | Get trending briefs |
+| `verify(claim, context?)` | Fact-check a claim against briefs |
+| `research(query, max_sources?, depth?, category?)` | Deep research on a topic |
+| `stream(categories?)` | Stream briefs via SSE (generator) |
+| `ticker(symbol)` | Get ticker overview |
+| `ticker_prices(symbols)` | Get live prices |
+| `ticker_sentiment(symbol, period?)` | Sentiment breakdown |
+| `ticker_signals(symbol, days?, threshold?)` | Trading signals |
+| `candles(symbol, interval?, range?)` | OHLCV candle data |
+| `technicals(symbol, range?)` | Full technical analysis |
+| `screener(filters)` | Screen stocks by filters |
+| `screener_natural(query)` | Natural language stock screen |
+| `crypto(symbol?)` | Crypto data |
+| `forex(pair?)` | Forex data |
+| `generate_report(ticker, tier?)` | Generate a report |
+
+## Error Handling
+
+```python
+from veroq import VeroqClient, AuthenticationError, RateLimitError, NotFoundError
+
+client = VeroqClient()
+
+try:
+    brief = client.brief("abc123")
+except AuthenticationError:
+    print("Invalid API key")
+except NotFoundError:
+    print("Brief not found")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after: {e.retry_after}s")
+```
+
+## Streaming
+
+```python
+client = VeroqClient()
+
+for brief in client.stream(categories="technology,science"):
+    print(f"[{brief.category}] {brief.headline}")
+```
+
+## Documentation
+
+Full API documentation: https://veroq.ai/docs

veroq-1.0.0/README.md

@@ -0,0 +1,125 @@
+# veroq
+
+VEROQ Python SDK -- verified intelligence for AI agents. The truth protocol for agentic AI.
+
+> **Migrating from `polaris-news`?** This is the official successor. All class names and env vars are backwards compatible. Just change your import from `polaris_news` to `veroq`.
+
+## Installation
+
+```bash
+pip install veroq
+```
+
+## Quick Start
+
+### Universal Agent Connector (recommended)
+
+```python
+from veroq import Agent
+
+agent = Agent()  # reads VEROQ_API_KEY (or POLARIS_API_KEY) from env
+result = agent.ask("What's happening with NVDA?")
+print(result.summary)
+
+# Full cross-reference -- everything about a ticker in one call
+full = agent.full("AAPL")
+print(full.price, full.technicals, full.earnings)
+
+# Subscribe to real-time events
+for event in agent.subscribe(tickers=["NVDA", "AAPL"], events=["brief"]):
+    print(event.type, event.ticker, event.data)
+```
+
+### Authenticate via CLI
+
+```bash
+veroq login    # opens GitHub in your browser -- API key saved automatically
+veroq whoami   # check your auth status
+veroq logout   # remove saved credentials
+```
+
+### Full Client
+
+```python
+from veroq import VeroqClient
+
+client = VeroqClient()  # auto-reads saved credentials
+feed = client.feed(category="technology", limit=10)
+for brief in feed.briefs:
+    print(brief.headline)
+```
+
+You can also pass a key explicitly or set the `VEROQ_API_KEY` environment variable. For backwards compatibility, `POLARIS_API_KEY` is also supported.
+
+## Backwards Compatibility
+
+If you are migrating from `polaris-news`, the following aliases are available:
+
+```python
+from veroq import PolarisClient  # alias for VeroqClient
+from veroq import PolarisError   # alias for VeroqError
+```
+
+Both `VEROQ_API_KEY` and `POLARIS_API_KEY` environment variables are supported. Credentials from both `~/.veroq/credentials` and `~/.polaris/credentials` are read.
+
+## Methods
+
+| Method | Description |
+|--------|-------------|
+| `feed(category?, limit?, page?, per_page?, min_confidence?)` | Get the news feed |
+| `brief(brief_id, include_full_text?)` | Get a single brief by ID |
+| `search(query, category?, page?, per_page?, sort?, min_confidence?, from_date?, to_date?, entity?, sentiment?)` | Search briefs |
+| `generate(topic, category?)` | Generate a brief on a topic |
+| `entities(q?, type?, limit?)` | List entities |
+| `entity_briefs(name, role?, limit?, offset?)` | Get briefs for an entity |
+| `trending_entities(limit?)` | Get trending entities |
+| `similar(brief_id, limit?)` | Get similar briefs |
+| `clusters(period?, limit?)` | Get brief clusters |
+| `data(entity?, type?, limit?)` | Get structured data points |
+| `agent_feed(category?, tags?, limit?, min_confidence?)` | Get agent-optimized feed |
+| `compare_sources(brief_id)` | Compare sources for a brief |
+| `trending(period?, limit?)` | Get trending briefs |
+| `verify(claim, context?)` | Fact-check a claim against briefs |
+| `research(query, max_sources?, depth?, category?)` | Deep research on a topic |
+| `stream(categories?)` | Stream briefs via SSE (generator) |
+| `ticker(symbol)` | Get ticker overview |
+| `ticker_prices(symbols)` | Get live prices |
+| `ticker_sentiment(symbol, period?)` | Sentiment breakdown |
+| `ticker_signals(symbol, days?, threshold?)` | Trading signals |
+| `candles(symbol, interval?, range?)` | OHLCV candle data |
+| `technicals(symbol, range?)` | Full technical analysis |
+| `screener(filters)` | Screen stocks by filters |
+| `screener_natural(query)` | Natural language stock screen |
+| `crypto(symbol?)` | Crypto data |
+| `forex(pair?)` | Forex data |
+| `generate_report(ticker, tier?)` | Generate a report |
+
+## Error Handling
+
+```python
+from veroq import VeroqClient, AuthenticationError, RateLimitError, NotFoundError
+
+client = VeroqClient()
+
+try:
+    brief = client.brief("abc123")
+except AuthenticationError:
+    print("Invalid API key")
+except NotFoundError:
+    print("Brief not found")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after: {e.retry_after}s")
+```
+
+## Streaming
+
+```python
+client = VeroqClient()
+
+for brief in client.stream(categories="technology,science"):
+    print(f"[{brief.category}] {brief.headline}")
+```
+
+## Documentation
+
+Full API documentation: https://veroq.ai/docs

veroq-1.0.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "veroq"
+version = "1.0.0"
+description = "VEROQ Python SDK — verified intelligence for AI agents. The truth protocol for agentic AI."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [
+    { name = "VEROQ", email = "dev@veroq.ai" },
+]
+keywords = ["veroq", "verified", "intelligence", "api", "sdk", "ai", "agents", "nlp", "truth", "financial"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "requests>=2.20",
+]
+
+[project.scripts]
+veroq = "veroq.cli:main"
+
+[project.optional-dependencies]
+async = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://veroq.ai"
+Documentation = "https://veroq.ai/docs"
+Repository = "https://github.com/veroq/veroq-python"
+"Bug Tracker" = "https://github.com/veroq/veroq-python/issues"
+Changelog = "https://veroq.ai/docs/changelog"
+
+[tool.hatch.build.targets.sdist]
+include = ["veroq/", "LICENSE", "README.md"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["veroq"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

veroq-1.0.0/veroq/__init__.py

@@ -0,0 +1,87 @@
+__version__ = "1.0.0"
+
+from .client import VeroqClient
+from .agent import Agent, AskResult, FullResult, SubscribeEvent
+from .exceptions import APIError, AuthenticationError, NotFoundError, VeroqError, RateLimitError
+from .types import (
+    Brief,
+    Cluster,
+    ClustersResponse,
+    ComparisonResponse,
+    DataPoint,
+    DataPointValue,
+    DataResponse,
+    DepthMetadata,
+    EntitiesResponse,
+    Entity,
+    EntityCrossRef,
+    ExtractResponse,
+    ExtractResult,
+    FeedResponse,
+    Provenance,
+    ResearchEntity,
+    ResearchMetadata,
+    ResearchResponse,
+    ResearchSourceUsed,
+    SearchResponse,
+    VerifyBrief,
+    VerifyResponse,
+    Source,
+    SourceAnalysis,
+    SourceVerification,
+)
+
+try:
+    from .async_client import AsyncVeroqClient
+except ImportError:
+    pass
+
+# Backwards compatibility aliases
+PolarisClient = VeroqClient
+PolarisError = VeroqError
+try:
+    AsyncPolarisClient = AsyncVeroqClient
+except NameError:
+    pass
+
+__all__ = [
+    "VeroqClient",
+    "AsyncVeroqClient",
+    "VeroqError",
+    "AuthenticationError",
+    "RateLimitError",
+    "NotFoundError",
+    "APIError",
+    # Backwards compatibility
+    "PolarisClient",
+    "PolarisError",
+    "Agent",
+    "AskResult",
+    "FullResult",
+    "SubscribeEvent",
+    "Brief",
+    "Source",
+    "Entity",
+    "Provenance",
+    "FeedResponse",
+    "SearchResponse",
+    "Cluster",
+    "ClustersResponse",
+    "DataPoint",
+    "DataPointValue",
+    "DataResponse",
+    "EntitiesResponse",
+    "ComparisonResponse",
+    "SourceAnalysis",
+    "ExtractResult",
+    "ExtractResponse",
+    "ResearchResponse",
+    "ResearchEntity",
+    "ResearchMetadata",
+    "ResearchSourceUsed",
+    "DepthMetadata",
+    "EntityCrossRef",
+    "SourceVerification",
+    "VerifyBrief",
+    "VerifyResponse",
+]

veroq-1.0.0/veroq/agent.py

@@ -0,0 +1,240 @@
+"""
+VEROQ Universal Agent Connector
+
+The simplest way to give any AI agent verified financial intelligence.
+
+    from veroq import Agent
+
+    agent = Agent()  # reads VEROQ_API_KEY or POLARIS_API_KEY from env
+    result = agent.ask("What's happening with NVDA?")
+    print(result.summary)
+
+    # Full cross-reference — everything about a ticker
+    full = agent.full("AAPL")
+    print(full.price, full.technicals, full.earnings)
+
+    # Subscribe to real-time events
+    for event in agent.subscribe(tickers=["NVDA", "AAPL"], events=["brief"]):
+        print(event)
+"""
+
+import json
+import os
+from typing import Any, Dict, Iterator, List, Optional
+
+import requests
+
+
+class AskResult:
+    """Result from /ask — structured financial intelligence."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self._data = data
+        self.question: str = data.get("question", "")
+        self.intents: List[str] = data.get("intents", [])
+        self.tickers: List[str] = data.get("tickers", [])
+        self.reasoning: List[str] = data.get("reasoning", [])
+        self.summary: str = data.get("summary", "")
+        self.data: Dict[str, Any] = data.get("data", {})
+        self.credits_used: int = data.get("credits_used", 0)
+
+    def __repr__(self) -> str:
+        return f"AskResult(tickers={self.tickers}, intents={self.intents}, credits={self.credits_used})"
+
+    def __str__(self) -> str:
+        return self.summary
+
+
+class FullResult:
+    """Result from /ticker/:symbol/full — complete cross-reference."""
+
+    def __init__(self, data: Dict[str, Any]):
+        self._data = data
+        self.ticker: str = data.get("ticker", "")
+        self.entity_name: str = data.get("entity_name", "")
+        self.sector: str = data.get("sector", "")
+        self.price: Dict[str, Any] = data.get("price", {})
+        self.sentiment: Dict[str, Any] = data.get("sentiment", {})
+        self.technicals: Dict[str, Any] = data.get("technicals", {})
+        self.earnings: Dict[str, Any] = data.get("earnings", {})
+        self.news: Dict[str, Any] = data.get("news", {})
+        self.insider: Dict[str, Any] = data.get("insider", {})
+        self.filings: Dict[str, Any] = data.get("filings", {})
+        self.analysts: Dict[str, Any] = data.get("analysts", {})
+        self.institutions: Dict[str, Any] = data.get("institutions", {})
+
+    def __repr__(self) -> str:
+        return f"FullResult({self.ticker} ${self.price.get('current', '?')})"
+
+    def __str__(self) -> str:
+        lines = [f"{self.entity_name} ({self.ticker})"]
+        if self.price.get("current"):
+            lines.append(f"Price: ${self.price['current']} ({self.price.get('change_pct', '?')}%)")
+        if self.technicals.get("signal"):
+            lines.append(f"Signal: {self.technicals['signal']} | RSI: {self.technicals.get('rsi_14', '?')}")
+        if self.earnings.get("next_date"):
+            lines.append(f"Next Earnings: {self.earnings['next_date']}")
+        return "\n".join(lines)
+
+
+class SubscribeEvent:
+    """A real-time event from /subscribe."""
+
+    def __init__(self, event_type: str, data: Dict[str, Any]):
+        self.type: str = event_type
+        self.ticker: Optional[str] = data.get("ticker")
+        self.data: Dict[str, Any] = data.get("data", data)
+        self.timestamp: str = data.get("timestamp", "")
+
+    def __repr__(self) -> str:
+        return f"SubscribeEvent({self.type}, ticker={self.ticker})"
+
+
+class Agent:
+    """
+    VEROQ Universal Agent Connector.
+
+    The simplest way to add verified financial intelligence to any AI agent.
+
+        agent = Agent(api_key="vq_live_...")
+        result = agent.ask("What's happening with NVDA?")
+        print(result.summary)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.thepolarisreport.com",
+        timeout: int = 30,
+    ):
+        # Support both VEROQ_API_KEY and POLARIS_API_KEY for backwards compatibility
+        self.api_key = api_key or os.environ.get("VEROQ_API_KEY") or os.environ.get("POLARIS_API_KEY", "")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {self.api_key}" if self.api_key else "",
+            "Content-Type": "application/json",
+            "User-Agent": "veroq-agent/1.0",
+        })
+
+    def ask(self, question: str) -> AskResult:
+        """
+        Ask any financial question. Returns structured data + markdown summary.
+
+            result = agent.ask("What's happening with NVDA?")
+            print(result.summary)
+            print(result.tickers)       # ['NVDA']
+            print(result.reasoning)     # ['Identified ticker: NVDA', ...]
+            print(result.data)          # Raw data from all sources
+        """
+        resp = self._session.post(
+            f"{self.base_url}/api/v1/ask",
+            json={"question": question},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return AskResult(resp.json())
+
+    def full(self, ticker: str) -> FullResult:
+        """
+        Get EVERYTHING about a ticker in one call.
+
+            result = agent.full("NVDA")
+            print(result.price)         # {'current': 178.68, 'change_pct': -0.95}
+            print(result.technicals)    # {'signal': 'neutral', 'rsi_14': 46.4}
+            print(result.earnings)      # {'next_date': '2026-05-20', ...}
+            print(result.insider)       # {'transactions': [...], 'total': 20}
+        """
+        resp = self._session.get(
+            f"{self.base_url}/api/v1/ticker/{ticker.upper()}/full",
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return FullResult(resp.json())
+
+    def subscribe(
+        self,
+        tickers: Optional[List[str]] = None,
+        events: Optional[List[str]] = None,
+    ) -> Iterator[SubscribeEvent]:
+        """
+        Subscribe to real-time financial events via SSE.
+
+            for event in agent.subscribe(tickers=["NVDA", "AAPL"], events=["brief"]):
+                print(event.type, event.ticker, event.data)
+        """
+        params = {}
+        if tickers:
+            params["tickers"] = ",".join(t.upper() for t in tickers)
+        else:
+            params["tickers"] = "*"
+        if events:
+            params["events"] = ",".join(events)
+
+        resp = self._session.get(
+            f"{self.base_url}/api/v1/subscribe",
+            params=params,
+            stream=True,
+            timeout=None,  # SSE is long-lived
+            headers={**self._session.headers, "Accept": "text/event-stream"},
+        )
+        resp.raise_for_status()
+
+        event_type = ""
+        data_lines: List[str] = []
+
+        for line in resp.iter_lines(decode_unicode=True):
+            if line is None:
+                continue
+            line = line.strip()
+            if line.startswith("event:"):
+                event_type = line[6:].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[5:].strip())
+            elif line == "" and event_type and data_lines:
+                # Complete event
+                try:
+                    data = json.loads("".join(data_lines))
+                    yield SubscribeEvent(event_type, data)
+                except json.JSONDecodeError:
+                    pass
+                event_type = ""
+                data_lines = []
+            elif line.startswith(":"):
+                pass  # heartbeat, ignore
+
+    def run_agent(self, slug: str, **inputs) -> Dict[str, Any]:
+        """
+        Run a marketplace agent.
+
+            result = agent.run_agent("sector-pulse", sector="Technology")
+            print(result["summary"])
+        """
+        resp = self._session.post(
+            f"{self.base_url}/api/v1/agents/run/{slug}",
+            json=inputs,
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def search(self, query: str, per_page: int = 10) -> Dict[str, Any]:
+        """Search intelligence briefs."""
+        resp = self._session.get(
+            f"{self.base_url}/api/v1/search",
+            params={"q": query, "per_page": per_page},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def verify(self, claim: str) -> Dict[str, Any]:
+        """Fact-check a claim against the intelligence corpus."""
+        resp = self._session.post(
+            f"{self.base_url}/api/v1/verify",
+            json={"claim": claim},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()