Loom-mcp: MCP Tool for Iterative Long - text Creation with Base Models

Loom MCP

Loom is an MCP server that enables users to collaborate with the base model to construct text and optimize the quality of long text creation through short - fragment iteration generation and selection.

Artificial intelligence chatbots Developer tools #Text Collaboration #Iterative Generation #Model Integration .Python

rating : 2.5 points

downloads : 5.8K

update time : 2025-12-03

Open Site

What is the Loom MCP Server?

Loom is an innovative text collaboration tool that changes the traditional way of one-time long text generation. By breaking the writing process into multiple short continuation steps, it allows you to carefully cultivate and select the best text development path, just like a gardener pruning branches. You start with a seed text, generate multiple possible continuation options, select the one that best suits your intention, and then continue this process to gradually build a complete, coherent, and high-quality long-form content.

How to Use Loom?

Using Loom is very simple: First, connect to the Loom server through the Claude Web interface, and then use the provided tools to start your collaborative writing journey. You can start with a seed text, generate multiple continuation options, select the most satisfactory one, and then continue this process. The whole process is like having a conversation with a creative partner. You are responsible for the direction and selection, and the model is responsible for providing creative options.

Use Cases

Loom is particularly suitable for scenarios that require high-quality and coherent long-form content creation, such as creative writing (novels, short stories), technical document writing, marketing copywriting, academic paper drafting, scriptwriting, etc. Any text creation task that requires fine control and high-quality output can benefit from Loom's collaborative approach.

Main Features

Text Tree Construction

Visualize the writing process as a tree structure, where each node represents a part of the text and branches represent different development directions. You can view the entire text tree at any time to understand the current writing path and possible alternative directions.

Intelligent Continuation Generation

Generate multiple high-quality short continuation options from the current focus node. Loom leverages the base model's advantages in short text generation to provide diverse creative choices, giving you more control.

Flexible Editing and Adjustment

Supports operations such as inserting custom text, editing existing nodes, and deleting unnecessary branches. You have full control over the text's development direction and can adjust and optimize the content at any time.

Multi-Model Support

Supports multiple base models through OpenRouter, including Llama, Claude Haiku, etc. You can choose the most suitable model according to the task requirements and even specify a specific model provider.

State Persistence

Automatically saves the text tree state to a local file to ensure that your work is not lost. You can interrupt the work at any time and continue from where you left off later.

Deep Integration with Claude

Designed specifically for the Claude Web interface and seamlessly integrated through the MCP protocol. You can directly use the Loom tool in the Claude conversation to enjoy a smooth collaborative experience.

Advantages

High-quality output: Avoids the quality decline problem in long text generation through short continuations

Full control: You have the right to choose at each step to control the text's development direction

Creative diversity: Generates multiple options each time, inspiring more creative possibilities

Flexible adjustment: You can go back, modify, or try different development paths at any time

User-friendly: Complex text creation can be completed through simple tool commands

Limitations

Requires human participation: Each step requires user selection and is not suitable for fully automated content generation

Learning curve: Requires understanding the concept of the text tree and how to use the tool

Depends on external services: Requires an OpenRouter API key and available model services

Network requirements: Requires a stable network connection to access Claude and model services

How to Use

Environment Setup

First, clone the Loom repository and set up a Python virtual environment. Install the necessary dependency packages and configure your OpenRouter API key.

Start the Server

Start the Loom MCP server and expose it to the Internet using ngrok or localtunnel so that Claude Web can access it.

Connect to Claude Web

Add Loom as a custom connector in the Claude Web interface. Enter the server address and name to complete the connection setup.

Start Collaborative Writing

Use the Loom tool in the Claude conversation to start your text creation journey. Start with a seed text and gradually build your text tree.

Usage Examples

Creative Story Writing

Create a short story about future technology. Build a coherent and interesting story line through step-by-step generation and selection.

Technical Document Writing

Write a user manual for a complex software system. Ensure the accuracy and completeness of the document through step-by-step generation.

Marketing Copywriting

Create attractive marketing copy for a new product. Try different styles and angles and select the most effective way of expression.

Academic Paper Drafting

Draft various parts of an academic paper to ensure logical coherence and academic rigor.

Frequently Asked Questions

What is the difference between Loom and directly using ChatGPT or Claude?

Do I need programming knowledge to use Loom?

Which AI models does Loom support?

Will the text tree state be saved? Can I continue after interruption?

How to select the best continuation option?

Is Loom free?

Related Resources

Loom GitHub Repository

The source code and latest version of the Loom MCP server

Model Context Protocol Documentation

Understand the technical details and specifications of the MCP protocol

OpenRouter Platform

Get an API key and view the list of supported models

Claude Web Interface

Use Claude and connect to the Loom server

ngrok Tunnel Service

A tool to expose a local server to the Internet

🚀 Loom MCP

Loom is an MCP server that enables collaborative text building with base models. Instead of generating one long text, you can follow these steps:

Begin with a seed to evoke the appropriate style or voice.
Generate multiple short continuations.
Select the best one.
Repeat the process.

This approach leverages the strength of base models (producing high - quality short continuations) while avoiding their weakness (long - form text drift).

🚀 Quick Start

📦 Installation

# Clone and enter directory
git clone https://github.com/YOUR_USERNAME/loom-mcp
cd loom-mcp

# Create venv and install
uv venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows
uv sync

# Add your OpenRouter API key
echo "OPENROUTER_API_KEY=sk-or-..." > .env

🏃‍♂️ Running

# Start the server
python -m uvicorn server:app --host 0.0.0.0 --port 8000

# In another terminal, expose to internet (pick one):
ngrok http 8000
# or
npx localtunnel --port 8000

🔗 Connect to Claude Web

Navigate to claude.ai → Settings → Connectors → Add custom connector.
Name: loom (or any preferred name).
URL: Your ngrok/localtunnel https URL.
Leave the OAuth fields blank.
Click Add, then Connect.

💻 Usage Examples

Basic Usage

Once connected, you can ask Claude to use the loom tools:

"Use loom_guide to show me how loom works"

"Use loom_seed with this text: >>47382910: anyone else's parents just"

"hey i just gave you a loom tool, you should check it out!"

"loom for a short story about Bears. be picky and reroll often"

📚 Documentation

🛠️ Tools

Property	Details
`loom_seed(text)`	Create new tree with seed text as root
`loom_branch(n, model, max_tokens, temperature, min_p)`	Generate N completions from focused node
`loom_focus(node_id)`	Move to a node (use first 8 chars of ID)
`loom_context()`	Get full text from root to focused node
`loom_view(full)`	See tree structure
`loom_siblings(full)`	See alternative branches at same level
`loom_children(full)`	See continuations from focused node
`loom_insert(text)`	Add custom text as child
`loom_edit(text, node_id)`	Change a node's text
`loom_delete(node_id)`	Remove a node and descendants
`loom_guide()`	Show full usage guide
`loom_seeds()`	Show guide on writing good seeds