STORM (Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking)

STORM is an LLM system designed to write Wikipedia-like articles from scratch using Internet research. It operates in two main stages:

1. Pre-writing stage: Conducts Internet-based research to collect references and generates an outline.
2. Writing stage: Uses the outline and references to generate a full-length article with citations.

To ensure high-quality research, STORM uses two strategies for question asking:

• Perspective-Guided Question Asking: Discovers different perspectives by surveying existing articles on similar topics.
• Simulated Conversation: Simulates a dialogue between a Wikipedia writer and a topic expert grounded in Internet sources to refine understanding and generate follow-up questions.

Co-STORM (Collaborative STORM) extends this by enabling human-AI collaboration through a collaborative discourse protocol. It involves three participants:

• Co-STORM LLM experts: Agents that generate grounded answers or raise follow-up questions.
• Moderator: An agent that generates thought-provoking questions based on retrieved information.
• Human user: A user who can observe the discourse or actively inject utterances to steer the discussion.

Co-STORM also maintains a dynamic mind map to organize information into a hierarchical concept structure, helping build a shared conceptual space between the human and the system.

By default, STORM uses the internet for grounding. To use your own data, use VectorRM to ground STORM on a custom corpus.

1. Prepare your CSV corpus

Your documents must be in a single CSV file with the following columns:

• content: (Required) The main text of the document.
• url: (Required) A unique identifier for the document. Ensure all documents have unique URLs.
• title: (Optional) The title of the document.
• description: (Optional) A description of the document.

2. Configure API Keys

• Set up your OpenAI API key.
• If using a Qdrant cloud server for the vector store, set QDRANT_API_KEY in secrets.toml.

3. Execution Modes

Offline Mode

Use this to save the vector store locally:

python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \
    --output-dir $OUTPUT_DIR \
    --vector-db-mode offline \
    --offline-vector-db-dir $OFFLINE_VECTOR_DB_DIR \
    --csv-file-path $CSV_FILE_PATH \
    --device $DEVICE_FOR_EMBEDDING(mps, cuda, cpu) \
    --do-research \
    --do-generate-outline \
    --do-generate-article \
    --do-polish-article

Online Mode

Use this to connect to a Qdrant server:

python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \
    --output-dir $OUTPUT_DIR \
    --vector-db-mode online \
    --online-vector-db-url $ONLINE_VECTOR_DB_URL \
    --csv-file-path $CSV_FILE_PATH \
    --device $DEVICE_FOR_EMBEDDING(mps, cuda, cpu) \
    --do-research \
    --do-generate-outline \
    --do-generate-article \
    --do-polish-article

Co-STORM allows for collaborative discourse between the system and the user. It uses a multi-agent LLM paradigm including experts and a moderator.

To use Co-STORM, initialize a CoStormRunner with CollaborativeStormLMConfigs, a RunnerArgument object, a LoggingWrapper, and a retrieval module (e.g., BingSearch).

Workflow:

1. Call warm_start() to build a shared conceptual space.
2. Call step() to observe a conversation turn, or step(user_utterance="...") to inject user input and steer the conversation.
3. Call knowledge_base.reorganize() and generate_report() to produce the final article.

from knowledge_storm.collaborative_storm.engine import CollaborativeStormLMConfigs, RunnerArgument, CoStormRunner
from knowledge_storm.lm import LitellmModel
from knowledge_storm.logging_wrapper import LoggingWrapper
from knowledge_storm.rm import BingSearch

# 1. Setup Configs and Models
lm_config = CollaborativeStormLMConfigs()
# (Configure various LMs using set_question_answering_lm, set_discourse_manage_lm, etc.)

# 2. Setup Runner
runner_argument = RunnerArgument(topic='Topic Name', ...)
logging_wrapper = LoggingWrapper(lm_config)
bing_rm = BingSearch(bing_search_api_key=os.environ.get("BING_SEARCH_API_KEY"), k=runner_argument.retrieve_top_k)
costorm_runner = CoStormRunner(lm_config=lm_config, runner_argument=runner_argument, logging_wrapper=logging_wrapper, rm=bing_rm)

# 3. Interactive Loop
costorm_runner.warm_start()
conv_turn = costorm_runner.step() # Observe
costorm_runner.step(user_utterance="Tell me more about X") # Steer

# 4. Generate Result
costorm_runner.knowledge_base.reorganize()
article = costorm_runner.generate_report()
print(article)

You can quickly test STORM's custom corpus capabilities using the Kaggle arXiv Paper Abstracts dataset.

1. Download and Process: Download arxiv_data_210930-054931.csv from Kaggle and use the helper script to format it for STORM:

   python examples/storm_examples/helper/process_kaggle_arxiv_abstract_dataset.py --input-path $PATH_TO_THE_DOWNLOADED_FILE --output-path $PATH_TO_THE_PROCESSED_CSV

2. Run STORM: Run the script using the processed CSV. You can input a topic like "The progress of multimodal models in computer vision".

   python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \
       --output-dir $OUTPUT_DIR \
       --vector-db-mode offline \
       --offline-vector-db-dir $OFFLINE_VECTOR_DB_DIR \
       --csv-file-path $PATH_TO_THE_PROCESSED_CSV \
       --device $DEVICE_FOR_EMBEDDING(mps, cuda, cpu) \
       --do-research \
       --do-generate-outline \
       --do-generate-article \
       --do-polish-article

3. Fastest Method: Alternatively, download a pre-embedded vector store to skip the embedding step:

   python examples/storm_examples/run_storm_wiki_gpt_with_VectorRM.py \
       --output-dir $OUTPUT_DIR \
       --vector-db-mode offline \
       --offline-vector-db-dir $DOWNLOADED_VECTOR_DB_DR \
       --do-research \
       --do-generate-outline \
       --do-generate-article \
       --do-polish-article

STORM (Synthesis of Topic Outlines through Retrieval and Multi-perspective Question Asking) is a knowledge curation engine that automates research by simulating conversations to collect information, generating outlines, and writing articles.

To use STORM, you must configure a STORMWikiLMConfigs object with different language models (it is recommended to use faster models for simulation and more powerful models for article generation) and a retrieval module (RM) like YouRM or BingSearch. The engine is controlled via the STORMWikiRunner class.

import os
from knowledge_storm import STORMWikiRunnerArguments, STORMWikiRunner, STORMWikiLMConfigs
from knowledge_storm.lm import LitellmModel
from knowledge_storm.rm import YouRM

# 1. Configure Language Models
lm_configs = STORMWikiLMConfigs()
openai_kwargs = {'api_key': os.getenv("OPENAI_API_KEY"), 'temperature': 1.0, 'top_p': 0.9}

gpt_35 = LitellmModel(model='gpt-3.5-turbo', max_tokens=500, **openai_kwargs)
gpt_4 = LitellmModel(model='gpt-4o', max_tokens=3000, **openai_kwargs)

lm_configs.set_conv_simulator_lm(gpt_35)
lm_configs.set_question_asker_lm(gpt_35)
lm_configs.set_outline_gen_lm(gpt_4)
lm_configs.set_article_gen_lm(gpt_4)
lm_configs.set_article_polish_lm(gpt_4)

# 2. Configure Retrieval Module
engine_args = STORMWikiRunnerArguments(...)
rm = YouRM(ydc_api_key=os.getenv('YDC_API_KEY'), k=engine_args.search_top_k)

# 3. Initialize and Run
runner = STORMWikiRunner(engine_args, lm_configs, rm)
topic = 'Your Research Topic'
runner.run(
    topic=topic,
    do_research=True,
    do_generate_outline=True,
    do_generate_article=True,
    do_polish_article=True,
)
runner.post_run()
runner.summary()