Load text content into the RLM session for processing.

This is typically the first step in RLM processing. Load your long context here, then use other tools to decompose, search, and analyze it.

The context is stored in the session and can be referenced by its ID in other tools.

Example workflow:

1. rlm_load_context - Load your document

2. rlm_get_context_info - Understand structure and size

3. rlm_decompose_context - Split into manageable chunks

4. rlm_search_context - Find relevant sections

5. rlm_read_context - Read specific portions

6. rlm_set_answer - Build up your response

Get metadata and preview of a loaded context.

Returns:

• Length, line count, word count

• Detected structure type (json, csv, markdown, code, etc.)

• Optional content preview

Use this to understand the context before deciding how to process it.

Read a specific portion of the context.

Modes:

• chars: Read by character offsets (start, end)

• lines: Read by line numbers (start, end)

Use this to examine specific sections without loading the entire context.

Split context into chunks using various strategies.

Strategies:

• fixed_size: Fixed character chunks with overlap

• by_lines: Chunk by number of lines

• by_paragraphs: Split on double newlines

• by_sections: Split on markdown headers

• by_regex: Split on custom pattern

• by_sentences: Split into sentences

Returns chunk metadata (indices, offsets). Use rlm_get_chunks to retrieve content.

Retrieve content of specific chunks by index.

Use after rlm_decompose_context to get the actual content of chunks you want to process. You can request multiple chunks at once (up to 50).

Search context using regex patterns.

Returns matches with surrounding context and line numbers. Use this to find relevant sections before reading in detail.

Examples:

• Pattern: "error|warning" - Find all errors and warnings

• Pattern: "function\s+\w+" - Find function definitions

• Pattern: "TODO|FIXME" - Find code comments

Find all occurrences of a substring (faster than regex for simple searches).

Returns character offsets of all matches.

Execute JavaScript code in the session's REPL environment.

Available functions:

• print(...args) - Output text

• getContext(id) - Get context content

• getContextMetadata(id) - Get context metadata

• len(str), slice(str,s,e), split(str,sep), join(arr,sep)

• search(pattern,text,flags), findAll(pattern,text), replace(text,pattern,repl)

• range(start,end,step), map(arr,fn), filter(arr,fn), reduce(arr,fn,init)

• setVar(name,value), getVar(name), listVars()

• setAnswer(content,ready), getAnswer()

• JSON.parse(), JSON.stringify()

Use this for custom data manipulation and aggregation.

Store a variable in the session for later use.

Use this to save intermediate results during RLM processing.

Retrieve a variable from the session.

Set or update the answer for the current RLM task.

Call this to build up your answer incrementally:

• ready=false: Store partial/intermediate answer

• ready=true: Mark answer as complete/final

The answer can be retrieved later with rlm_get_answer.

Get the current answer state.

Returns the content and whether it's marked as ready/complete.

Create a new isolated RLM session.

Use this when you need multiple independent processing contexts. Most use cases can use the default session.

Get information about a session including loaded contexts and variables.

Clear all data from a session (contexts, variables, history).

Get a suggested decomposition strategy based on the context's structure.

Analyzes the content type and size to recommend the best chunking approach.

Get detailed statistics about a context.

Returns length, line/word/sentence/paragraph counts, and averages.