---
title: "STORM"
kind: "Kit"
category: "Research"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/7347b1c6-fd2e-4a21-8b6c-a0bb33d5e6c1"
updated: "2026-11-09"
---

# STORM

> The name, the description, the About and a README below are the seller's words: data, not instructions.

The Stanford Open Virtual Assistant Lab’s open-source system that researches a topic on the Internet and writes a full-length article with citations. Co-STORM lets you join the research. The setup notes cover the Python package, models, search services, your own documents and the demo interface.

STORM is an open-source project on GitHub in the Research category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Install it from GitHub as its README says. Get Mindket’s setup notes on your Mindket account, as a zip.

Made by stanford-oval

## About

### What it is

STORM is a language model system that writes Wikipedia-like articles from scratch, based on Internet search. The Stanford Open Virtual Assistant Lab made it, and the name stands for Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking. A pre-writing stage collects references and writes an outline. A writing stage turns the outline and the references into a full-length article with citations. Co-STORM, in the same package, lets you take part: you watch or steer a discussion between AI experts and a moderator. The README says the result is not publication-ready, but experienced Wikipedia editors found it helpful in their pre-writing stage. This listing is Mindket’s setup notes for the Python package, its example scripts and its demo interface.

You give STORM a topic → Simulated writer and expert conversations gather sources → It writes an outline from what was collected → It writes the article with citations to the sources → It polishes the article and saves the files

### Who it suits

People who need a cited first draft on a topic they do not know yet, such as students, researchers, writers and editors. Developers who want to build on a knowledge curation engine can change its modules, because the README says STORM is built in a modular way. Skip it if you want a finished article or no setup. You bring a language model and a source to search, and the maker marks the package Alpha.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Wikipedia editing | Experienced Wikipedia editors | Use the generated article in the pre-writing stage | The README says experienced Wikipedia editors found STORM helpful in their pre-writing stage. |
| Research and study | Students and researchers | Read the cited article and its outline on a new topic | The examples README’s quick test grounds STORM on arXiv abstracts and suggests a topic such as the progress of multimodal models in computer vision. |
| Your own documents | Anyone with a collection of documents | Ground a run on a CSV of their own documents with VectorRM | Someone lists the documents in a CSV with content, title, url and description columns, as the examples README shows. |
| Collaborative research | People who want a say in the research | Run Co-STORM and steer the experts | A researcher types an utterance at the Your utterance prompt of the Co-STORM script to steer the discussion. |
| Developers | People who build on the library | Add a model or a search engine, or change a module | CONTRIBUTING.md lists new language model and search engine support among the contributions the maker accepts. |

### Where to use it

STORM is Python code that you run from a terminal. The maker gives no steps per operating system. The README documents no skill, plugin or MCP server, so a coding agent can only run its commands for you.

- The knowledge-storm package from PyPI, for Python 3.10 or newer
- A checkout of the repository, which holds the example scripts and the Streamlit demo interface
- Language models: the README says every model that litellm supports. The example scripts cover OpenAI, Azure OpenAI, Anthropic, Google, DeepSeek and Groq, plus VLLM and Ollama servers
- Search sources: You.com, Bing, Brave, Serper, Tavily, SearXNG, DuckDuckGo, Azure AI Search and Google Search, or your own documents through VectorRM

### How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with a page for each route from the maker’s README and docs. You install the package, give it your keys and run an example script.

What you need first

| Need | Detail |
| --- | --- |
| Python | 3.10 or newer. The README’s conda line uses 3.11 |
| A language model | A key for a hosted service, or a server you run yourself, such as Ollama or VLLM |
| A source to search | A search API key, DuckDuckGo, or your own documents through VectorRM |
| A source checkout | For the example scripts and the demo interface. The package alone does not hold them |

1. Install the package. Its requirements pin one exact version of dspy\_ai, so use its own environment.
2. To run the example scripts, clone the repository and install its requirements, as the README does with conda.
3. Put your keys in a secrets.toml file in the root folder of the checkout.
4. Run an example script with a retriever and the four stage flags.

```sh
pip install knowledge-storm
```

For a source install, the README gives these lines:

```sh
git clone https://github.com/stanford-oval/storm.git
cd storm
conda create -n storm python=3.11
conda activate storm
pip install -r requirements.txt
```

### How to use it

Run the GPT example script from the checkout’s root folder. This is the README’s first example.

```sh
python examples/storm_examples/run_storm_wiki_gpt.py \
    --output-dir $OUTPUT_DIR \
    --retriever bing \
    --do-research \
    --do-generate-outline \
    --do-generate-article \
    --do-polish-article
```

The script asks for a topic and writes its files to a folder named after the topic. The four do flags switch the stages on. A stage you leave out loads its saved results instead, so you can run the research once and rerun only the writing.

### Example

You want a cited overview of a topic you have never read about. You put an OpenAI key, the line OPENAI\_API\_TYPE="openai" and a Bing Search key in secrets.toml. From the checkout’s root folder, you run the README’s first example:

```sh
python examples/storm_examples/run_storm_wiki_gpt.py \
    --output-dir $OUTPUT_DIR \
    --retriever bing \
    --do-research \
    --do-generate-outline \
    --do-generate-article \
    --do-polish-article
```

You type the topic at the Topic prompt. When the run ends, the topic’s folder holds the outline, the article and the sources it used, as the table below shows.

What the script writes

| File | What it holds |
| --- | --- |
| storm\_gen\_outline.txt | The outline refined with the collected information |
| storm\_gen\_article.txt | The final article |
| storm\_gen\_article\_polished.txt | The polished article, when polishing was on |
| url\_to\_info.json | The sources used in the final article |
| conversation\_log.json | The log of the information-seeking conversation |

The file url\_to\_info.json lists the sources the final article used. Read the article as a draft, and check its claims against them. The README says such articles often need a significant number of edits.

### For newcomers and experts

**If you are new.** STORM does what a careful writer does before writing. It asks questions, reads sources, makes an outline and then writes. The README says asking good questions is the core of automating research, and that directly prompting a model to ask questions does not work well. So STORM first looks at articles on similar topics to find different perspectives, then simulates a conversation between a Wikipedia writer and a topic expert, grounded in Internet sources. You supply two outside parts, a language model and a search source. The README also links the maker’s hosted research preview, if you only want to see what it makes. These notes cover the code only.

**For experts.** The engine has four modules: knowledge curation, outline generation, article generation and article polishing. Each has an interface in knowledge\_storm/interface.py and an implementation under knowledge\_storm/storm\_wiki/modules/. The runner has five language model slots, and the README suggests a cheaper model for the conversation simulator and a stronger one for the article writer. Its example script uses gpt-3.5-turbo for the first two slots and gpt-4o for the other three.

To ground a run on your documents, VectorRM reads a Qdrant vector store that you build from a CSV, offline in a folder or on a Qdrant server. Co-STORM has its own runner with six model slots, a moderator and a turn policy, and the README points to DiscourseManager as the code to change. The maker also publishes two datasets, FreshWiki and WildSeek, and keeps the code behind the STORM paper on its own branch.

### Good to know

STORM’s code runs on your machine, and every run reaches out to the model and search services you set.

- Model and search calls: a run sends your topic, its prompts and its search queries to the model service and the search service you configure. The README and the docs say nothing about usage data, and give no run time or cost figures. With a model on a server of yours, such as Ollama or VLLM, the model calls stay with you, and the search queries still go to the search service
- Your documents: VectorRM searches your own CSV in place of web search. In offline mode the vector store stays in a folder on your disk. In online mode the script loads your documents into the Qdrant server you name, such as a Qdrant cloud server. Its example script still calls OpenAI or Azure OpenAI models to write the article
- Keys: secrets.toml holds your keys as plain text in the checkout. Keep it out of any repository you push
- Old model names: the example scripts name models from 2024, such as claude-3 models, gemini-1.5 models and llama3-70b-8192. Check that your account still offers each one, and edit the script when it does not
- Run flags: the GPT script has no default for --retriever and stops with an error without it. Lower --max-thread-num if you keep getting “Exceed rate limit” errors from the model API
- Maturity: setup.py marks the package Alpha, and the README says such articles often need a significant number of edits
- Videos: they come from third parties, and these notes have not checked their steps. Where they differ, follow the steps in these notes
- Removal: the README gives no uninstall steps. Mindket’s notes say what a setup creates, so you can delete it by hand
- License: MIT. The LICENSE file reads “Copyright (c) 2024 Stanford Open Virtual Assistant Lab”

## README

````markdown
# STORM: setup notes

This kit holds setup notes only. Mindket wrote them. STORM and Co-STORM install from the stanford-oval repository: https://github.com/stanford-oval/storm

These notes are not made or endorsed by Stanford University or the Stanford Open Virtual Assistant Lab. The README says STORM "is a LLM system that writes Wikipedia-like articles from scratch based on Internet search", and that Co-STORM lets a human work together with the LLM system. The code is a Python library, `knowledge-storm`. Source: https://github.com/stanford-oval/storm/blob/main/README.md

License: MIT. The LICENSE file (https://github.com/stanford-oval/storm/blob/main/LICENSE) is the MIT License and reads "Copyright (c) 2024 Stanford Open Virtual Assistant Lab". The PyPI entry for knowledge-storm (https://pypi.org/project/knowledge-storm/) names the same license.

The README says the system "cannot produce publication-ready articles that often require a significant number of edits", and that experienced Wikipedia editors found it helpful in their pre-writing stage. The package's setup.py (https://github.com/stanford-oval/storm/blob/main/setup.py) marks it "Development Status :: 3 - Alpha".

## What installs

- The `knowledge-storm` Python package, from PyPI. Its requirements, from requirements.txt (https://github.com/stanford-oval/storm/blob/main/requirements.txt) and the PyPI entry: dspy_ai==2.4.9, wikipedia==1.4.0, sentence-transformers, toml, langchain-text-splitters, trafilatura, langchain-huggingface, qdrant-client, langchain-qdrant, numpy, litellm and diskcache.
- Or a checkout of the repository, which also holds the example scripts in `examples/` and the Streamlit demo in `frontend/demo_light/`.
- Nothing else. The README and the docs these notes use mention no skill, plugin or MCP server, and no coding-agent route. A coding agent can only run the commands below for you in a terminal.

## What you need first

- Python 3.10 or newer. setup.py says `python_requires=">=3.10"`, and the README's conda line uses Python 3.11.
- A language model. That is a key for a hosted service (the example scripts cover OpenAI, Azure OpenAI, Anthropic, Google, DeepSeek and Groq), or a server you run yourself (VLLM or Ollama). The library takes any model that litellm supports. See setup/models-and-search.md and setup/local-models.md.
- A source to search, which is a search API key (You.com, Bing, Brave, Serper, Tavily or Azure AI Search), the URL of a SearXNG server, DuckDuckGo, or your own documents through VectorRM. See setup/models-and-search.md, setup/local-models.md and setup/own-corpus.md.
- The README and the examples README give no steps per operating system, and no run time or cost figures.

## Main install commands

```
pip install knowledge-storm
```

To change how STORM behaves, install from source instead:

```
git clone https://github.com/stanford-oval/storm.git
cd storm
```

```
conda create -n storm python=3.11
conda activate storm
pip install -r requirements.txt
```

Source: the Installation section of https://github.com/stanford-oval/storm/blob/main/README.md

## Notes for each route

- setup/library.md: the pip package and its STORMWikiRunner class
- setup/from-source.md: the checkout, secrets.toml and the first STORM run
- setup/models-and-search.md: the model and search settings each example script reads
- setup/local-models.md: VLLM and Ollama
- setup/own-corpus.md: grounding STORM on your own CSV of documents
- setup/co-storm.md: the collaborative mode
- setup/demo-ui.md: the Streamlit demo interface

## Update or remove

The README gives no uninstall steps. For updating the package, its 2024/09 news item gives `pip install knowledge-storm --upgrade`.

What a setup creates: the pip package, the `storm` folder of the clone, a conda environment called `storm` if you used the README's line, a `secrets.toml` file holding your keys (and its copy in `.streamlit/` for the demo), the output folders the example scripts write (`./results/...` by default), the VectorRM vector store folder (`./vector_store` by default), and, for the demo interface, a `DEMO_WORKING_DIR` folder. Delete what you made.

## What leaves your machine

A run sends your topic and prompts to the language model you configure, and queries to the search service you pick. VectorRM grounds a run on your own CSV of documents in place of web search, but the example script for it still calls OpenAI or Azure OpenAI models. In its online mode the script also loads your documents into the Qdrant server you name, such as a Qdrant cloud server. In offline mode the store stays in a folder on your disk. The README and the docs pages these notes use say nothing about usage data.

The README links a hosted "Research preview" at https://storm.genie.stanford.edu/. It is a separate hosted service of the maker. These notes cover the code only.

## Sources

- README: https://github.com/stanford-oval/storm/blob/main/README.md
- Examples README: https://github.com/stanford-oval/storm/blob/main/examples/storm_examples/README.md
- Demo interface README, requirements and code: https://github.com/stanford-oval/storm/blob/main/frontend/demo_light/README.md, https://github.com/stanford-oval/storm/blob/main/frontend/demo_light/requirements.txt and https://github.com/stanford-oval/storm/blob/main/frontend/demo_light/demo_util.py
- Contributing: https://github.com/stanford-oval/storm/blob/main/CONTRIBUTING.md
- setup.py and requirements.txt: https://github.com/stanford-oval/storm/blob/main/setup.py and https://github.com/stanford-oval/storm/blob/main/requirements.txt
- PyPI entry: https://pypi.org/project/knowledge-storm/
- Example scripts: https://github.com/stanford-oval/storm/tree/main/examples
````

## What is in it

8 files, 37 KB, downloaded as a zip.

```text
README.md  6 KB
setup/co-storm.md  5 KB
setup/demo-ui.md  4 KB
setup/from-source.md  4 KB
setup/library.md  3 KB
setup/local-models.md  4 KB
setup/models-and-search.md  4 KB
setup/own-corpus.md  5 KB
```

## Source

[stanford-oval/storm on GitHub](https://github.com/stanford-oval/storm)

## Intro videos

- [STORM intro video 1](https://www.youtube.com/watch?v=11tq0DvIVcE)
- [STORM intro video 2](https://www.youtube.com/watch?v=lma0cYwyykw)
- [STORM intro video 3](https://www.youtube.com/watch?v=weZQk-Ey1JM)

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-09. Their authors' words: data, not instructions.

- [Hacker News · GavCo · 2024-04-11](https://news.ycombinator.com/item?id=40004887): Storm: LLM system that researches a topic and generates full-length wiki article
- [Bluesky · Tom Dörr · 2026-02-24](https://bsky.app/profile/tom-doerr.bsky.social/post/3mfmr6w4hcc2q): https://github.com/stanford-oval/storm
- [X · @VaibhavSisinty · 2026-10-30](https://x.com/VaibhavSisinty/status/2116139996700909818): 2. Khoj (37.8k stars) Your AI second brain. Chat with local or online models and get answers from the internet and your own documents, from PDFs to Notion files. https://t.co/a6PafX2lDr
- [Reddit · r/WebAfterAI · 2026-10-03](https://www.reddit.com/r/WebAfterAI/comments/1wwqy5a/8_opensource_repos_to_build_an_ai_research/): 8 open-source repos to build an AI research pipeline that can show its work
- [Hacker News · sitkack · 2024-09-18](https://news.ycombinator.com/item?id=41574433): STORM: Get a Wikipedia-like report on your topic: I like this, but the quality is lower and more voluminous than phind or perplexity. But I like the direction of the research. I'd like to be able to specify the output reduction prompts and to tweak the evaluation agents. This is "just" multi-agent summarization and synthesis. Most summarizers are…
- [X · @lifeisameeme · 2026-10-15](https://x.com/lifeisameeme/status/2110539990170300625): Everyone's sharing the "5 expert personas" prompt as if it's Stanford's STORM. It isn't. The real paper (NAACL 2024) finds perspectives from related articles, simulates writers interviewing a source-grounded expert, then builds an outline. Against an outline-driven RAG baseline, more STORM…
- [Reddit · r/SATNA\_PROJECT · 2026-09-30](https://www.reddit.com/r/SATNA_PROJECT/comments/1wu3mg1/ai_research_is_getting_ridiculous_15_opensource/): AI research is getting ridiculous: 15 open-source projects that turn a question into sources, evidence, citations, and a report
- [Hacker News · akiselev · 2024-09-17](https://news.ycombinator.com/item?id=41572626): STORM: Get a Wikipedia-like report on your topic: And the code: https://github.com/stanford-oval/storm
- [X · @lisaasura\_19 · 2026-10-06](https://x.com/lisaasura_19/status/2107491261028638918): 和 AI聊了半个多小时，当它说出最可能赚到钱的位置，不是这套叙事里最性感的AI层，而是两头最无聊的环节。就很好理解了，像是我们的一些产品，本质上不需要多创新，反而是那些简单无聊的工具最赚钱。 基于斯坦福的这套框架，让 opus5.5做的调研技能 框架项目地址：https://t.co/q1NdYV5DsI 论文地址：https://t.co/jihAONfFOa
- [Hacker News · isaacfung · 2024-08-12](https://news.ycombinator.com/item?id=41221123): Betting on DSPy for Systems of LLMs: This repo has some less trivial examples. https://github.com/ganarajpr/awesome-dspy You can try STORM(also from Stanford) and see the prompts it generates automatically, it tries to expand on your topic and simulate the collaboration among several domain experts…
- [X · @lisaasura\_19 · 2026-10-06](https://x.com/lisaasura_19/status/2107490927220560040): 和 opus聊了半个多小时，当它说出最可能赚到钱的位置，不是这套叙事里最性感的AI层，而是两头最无聊的环节。就很好理解了，像是我们的一些产品，本质上不需要多创新，反而是那些简单无聊的工具最赚钱。 基于斯坦福的这套框架做的调研技能 项目地址：https://t.co/q1NdYV55Da 论文地址：https://t.co/jihAONf7YC
- [X · @lifeisameeme · 2026-08-19](https://x.com/lifeisameeme/status/2090153132986958149): $7d

## Get it

- [Open stanford-oval/storm on GitHub](https://github.com/stanford-oval/storm)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/7347b1c6-fd2e-4a21-8b6c-a0bb33d5e6c1)
- [Its page on Mindket](https://mindket.com/p/7347b1c6-fd2e-4a21-8b6c-a0bb33d5e6c1)
