Recursive Context

Recursive Context, previously documented as RELP, lets your LLM work with documentation larger than its context window by decomposing queries and orchestrating multiple focused retrievals.

The Problem

Modern LLMs have context windows ranging from 8K to 200K tokens. But real-world documentation often exceeds these limits:

• A typical codebase: 500K+ tokens of docs, comments, and READMEs
• Enterprise documentation: Often 1M+ tokens across wikis and specs
• API references: Can easily reach 200K+ tokens

Without Recursive Context, you either truncate your docs (losing context) or pay to send everything (expensive and slow). Both approaches lead to incomplete answers and unsupported claims.

How Recursive Context Works

Recursive Context solves this by breaking complex queries into focused sub-queries, each retrieving precisely relevant context within your token budget.

The Three Recursive Context Tools

snipara_decompose("implement auth system")

{

  "sub_queries": [

    "login flow and validation",

    "JWT token generation",

    "session management"

  ],

  "estimated_tokens": 12000

}

snipara_multi_query({

  queries: ["login flow", "JWT tokens"],

  max_tokens_per_query: 4000

})

snipara_plan("refactor auth to use OAuth2")

{

  "strategy": "RELEVANCE_FIRST",

  "steps": [...],

  "total_estimated_tokens": 25000

}

Plan Availability

Token Budget Management

Recursive Context intelligently distributes your token budget across sub-queries:

Reducing Hallucination

Recursive Context reduces unsupported claims through several mechanisms:

• Grounded responses: Every answer is based on actual documentation, not just training data
• Focused context: Each sub-query gets precisely relevant sections, reducing ambiguity
• Source attribution: Responses include file paths and line numbers for verification
• Shared context: Team coding standards are always injected, preventing non-compliant suggestions

Example: Complex Task Execution

# Your LLM receives this complex request

"Implement user authentication with JWT tokens,

 following our existing patterns and error handling"

 Step 1: LLM calls snipara_decompose

snipara_decompose("implement auth with JWT")

 Step 2: LLM calls snipara_multi_query for each sub-query

snipara_multi_query(["login flow", "JWT tokens", "sessions"])

 Step 3: LLM calls snipara_shared_context for team standards

snipara_shared_context("error handling patterns")

 Result: Accurate, grounded implementation

Expected Query Usage

Different task complexities consume different numbers of queries:

Next Steps