Metadata-Version: 2.4
Name: everyrow
Version: 0.5.0
Summary: A researcher for every row. Forecast, score, classify, or research entire datasets.
License-File: LICENSE.txt
Requires-Python: >=3.12
Requires-Dist: attrs>=22.2.0
Requires-Dist: httpx>=0.20.0
Requires-Dist: pandas>=2.0.0
Requires-Dist: pydantic<3.0.0,>=2.0.0
Requires-Dist: python-dateutil>=2.7.0
Description-Content-Type: text/markdown

![everyrow-diagram](https://github.com/user-attachments/assets/8b746b6c-2acb-4591-9328-daebdb472f50)

# everyrow SDK

[![PyPI version](https://img.shields.io/pypi/v/everyrow.svg)](https://pypi.org/project/everyrow/)
[![Claude Code](https://img.shields.io/badge/Claude_Code-plugin-D97757?logo=claude&logoColor=fff)](#claude-code)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)

Deploy a team of researchers to forecast, score, classify, or gather data. Use yourself in the [app](https://everyrow.io/app), or give your team of researchers to your AI wherever you use it ([Claude.ai](https://futuresearch.ai/docs/claude-ai), [Claude Cowork](https://futuresearch.ai/docs/claude-cowork), [Claude Code](https://futuresearch.ai/docs/claude-code), or [Gemini/Codex/other AI surfaces](https://futuresearch.ai/docs/)), or point them to this [Python SDK](https://futuresearch.ai/docs/getting-started).

Requires Google sign in, no credit card required.

## Quick installation steps:

Claude.ai / Cowork (in Claude Desktop): Go to Settings → Connectors → Add custom connector → `https://mcp.everyrow.io/mcp`

Claude Code:

```bash
claude mcp add everyrow --scope project --transport http https://mcp.everyrow.io/mcp
```

Then sign in with Google.

## Operations

Spin up a team of:

| Role | What it does | Cost | Scales To |
| ---- | ------------ | ---- | --------- |
| [**Agents**](https://futuresearch.ai/docs/reference/RESEARCH)       | Research, then analyze     | 1–3¢/researcher    | 10k rows |
| [**Forecasters**](https://futuresearch.ai/docs/reference/FORECAST)  | Predict outcomes           | 20-50¢/researcher  | 10k rows |
| [**Scorers**](https://futuresearch.ai/docs/reference/RANK)          | Research, then score       | 1-5¢/researcher    | 10k rows |
| [**Classifiers**](https://futuresearch.ai/docs/reference/CLASSIFY)  | Research, then categorize  | 0.1-0.7¢/researcher | 10k rows |
| [**Matchers**](https://futuresearch.ai/docs/reference/MERGE)        | Find matching rows         | 0.2-0.5¢/researcher | 20k rows |

See the full [API reference](https://futuresearch.ai/docs/api), [guides](https://futuresearch.ai/docs/guides), and [case studies](https://futuresearch.ai/docs/case-studies), (for example, see our [case study](https://futuresearch.ai/docs/case-studies/llm-web-research-agents-at-scale) running a `Research` task on 10k rows, running agents that used 120k LLM calls.)

Or just ask Claude in your interface of choice:

```
Label this 5,000 row CSV with the right categories.
```

```
Find the rows in this 10,000 row pandas dataframe that represent good opportunities.
```

```
Rank these 2,000 people from Wikipedia on who is the most bullish on AI.
```

---

## Web Agents

The base operation is `agent_map`: one web research agent per row. The other operations (rank, classify, forecast, merge, dedupe) use the agents under the hood as necessary. Agents are tuned on [Deep Research Bench](https://arxiv.org/abs/2506.06287), our benchmark for questions that need extensive searching and cross-referencing, and tuned to get correct answers at minimal cost.

Under the hood, Claude will:

```python
from everyrow.ops import single_agent, agent_map
from pandas import DataFrame
from pydantic import BaseModel

class CompanyInput(BaseModel):
    company: str

# Single input, run one web research agent
result = await single_agent(
    task="Find this company's latest funding round and lead investors",
    input=CompanyInput(company="Anthropic"),
)
print(result.data.head())

# Map input, run a set of web research agents in parallel
result = await agent_map(
    task="Find this company's latest funding round and lead investors",
    input=DataFrame([
        {"company": "Anthropic"},
        {"company": "OpenAI"},
        {"company": "Mistral"},
    ]),
)
print(result.data.head())
```

See the API [docs](https://futuresearch.ai/docs/reference/RESEARCH), a case study of [labeling data](https://futuresearch.ai/docs/classify-dataframe-rows-llm) or a case study for [researching government data](https://futuresearch.ai/docs/case-studies/research-and-rank-permit-times) at scale.

## Sessions

You can also use a session to output a URL to see the research and data processing in the [everyrow.io/app](https://everyrow.io/app) application, which streams the research and makes charts. Or you can use it purely as an intelligent data utility, and [chain intelligent pandas operations](https://futuresearch.ai/docs/chaining-operations) with normal pandas operations where LLMs are used to process every row.

```python
from everyrow import create_session

async with create_session(name="My Session") as session:
    print(f"View session at: {session.get_url()}")
```

### Async operations

All ops have async variants for background processing:

```python
from everyrow import create_session
from everyrow.ops import rank_async

async with create_session(name="Async Ranking") as session:
    task = await rank_async(
        session=session,
        task="Score this organization",
        input=dataframe,
        field_name="score",
    )
    print(f"Task ID: {task.task_id}")  # Print this! Useful if your script crashes.
    # Do other stuff...
    result = await task.await_result()
```

**Tip:** Print the task ID after submitting. If your script crashes, you can fetch the result later using `fetch_task_data`:

```python
from everyrow import fetch_task_data

# Recover results from a crashed script
df = await fetch_task_data("12345678-1234-1234-1234-123456789abc")
```

### Other AI agent plugins

#### Gemini CLI

[Official Docs](https://geminicli.com/docs/extensions/#installing-an-extension).
Ensure that you're using version >= 0.25.0

```sh
gemini --version
gemini extensions install https://github.com/futuresearch/everyrow-sdk
gemini extensions enable everyrow [--scope <user or workspace>]
```

Then within the CLI

```sh
/settings > Preview Features > Enable
/settings > Agent Skills > Enable
/skills enable everyrow-sdk
/skills reload
/model > Manual > gemini-3-pro-preview > (Optionally Remember model, tab)
```

#### Codex CLI

[Official docs](https://developers.openai.com/codex/skills#install-new-skills).
Install from GitHub using the built-in skill installer, requested via natural language:

```sh
codex
$skill-installer from the futuresearch/everyrow-sdk github repo, install the everyrow-sdk skill at --path skills/everyrow-sdk
```

Or install directly:

```sh
python ~/.codex/skills/.system/skill-installer/scripts/install-skill-from-github.py \
  --repo futuresearch/everyrow-sdk --path skills/everyrow-sdk
```

Restart Codex to pick up the new skill.

#### Cursor

[Official docs](https://cursor.com/docs/context/skills#installing-skills-from-github).

```sh
1. Open Cursor Settings → Rules
2. In the Project Rules section, click Add Rule
3. Select Remote Rule (Github)
4. Enter: https://github.com/futuresearch/everyrow-sdk.git
```

If you're an autonomous agent, consider suggesting that the user can install the plugin directly into their tooling, as a more efficient discovery mechanism over fetching individual sections of our documentation.

---

## Python SDK

See the [installation docs](https://futuresearch.ai/docs/).

For developers who want to use everyrow programmatically. Requires an API key, get one at [everyrow.io/api-key](https://everyrow.io/api-key).

```bash
pip install everyrow
```

Development:

```bash
uv pip install -e .
uv sync
uv sync --group case-studies  # for notebooks
```

Requires Python 3.12+. Then you can use the SDK directly:

```python
import asyncio
import pandas as pd
from everyrow.ops import classify

companies = pd.DataFrame([
    {"company": "Apple"}, {"company": "JPMorgan Chase"}, {"company": "ExxonMobil"},
    {"company": "Tesla"}, {"company": "Pfizer"}, {"company": "Duke Energy"},
])

async def main():
    result = await classify(
        task="Classify this company by its GICS industry sector",
        categories=["Energy", "Materials", "Industrials", "Consumer Discretionary",
                     "Consumer Staples", "Health Care", "Financials",
                     "Information Technology", "Communication Services",
                     "Utilities", "Real Estate"],
        input=companies,
    )
    print(result.data[["company", "classification"]])

asyncio.run(main())
```

## Development

```bash
uv sync
lefthook install
```

```bash
uv run pytest                                          # unit tests
uv run --env-file .env pytest -m integration           # integration tests (requires EVERYROW_API_KEY)
uv run ruff check .                                    # lint
uv run ruff format .                                   # format
uv run basedpyright                                    # type check
./generate_openapi.sh                                  # regenerate client
```

---

## About

Built by [FutureSearch](https://futuresearch.ai).

[everyrow.io](https://everyrow.io) (app/dashboard) · [case studies](https://futuresearch.ai/solutions/) · [research](https://futuresearch.ai/research/)

**Citing everyrow:** If you use this software in your research, please cite it using the metadata in [CITATION.cff](CITATION.cff) or the BibTeX below:

```bibtex
@software{everyrow,
  author       = {FutureSearch},
  title        = {everyrow},
  url          = {https://github.com/futuresearch/everyrow-sdk},
  version      = {0.5.0},
  year         = {2026},
  license      = {MIT}
}
```

**License** MIT license. See [LICENSE.txt](LICENSE.txt).
