14 Dec 17:42

ovitrac

24f70b4

RAGIX 0.60.0 – Contractive Reasoning & Agentic Profiles Latest

Latest

RAGIX v0.60.0 Release Notes

Release Date: 2025-12-14
Author: Olivier Vitrac, PhD, HDR | olivier.vitrac@adservio.fr | Adservio

Overview

Version 0.60.0 enhances RAGIX's position as a sovereign swiss knife for industrial-scale code auditing. This release focuses on:

MCP Server Enhancement — 5 new tools for comprehensive system introspection
Parallel KOAS Execution — Faster audits through dependency-aware parallelization
French i18n Fixes — Proper UTF-8 diacritics in audit reports
System Introspection — GPU, CPU, memory, and model management

Key Features

1. MCP Server v0.8.0 (22 Tools Total)

Five new tools expand RAGIX's MCP capabilities:

Tool	Purpose
`ragix_ast_scan`	Extract AST symbols from source code
`ragix_ast_metrics`	Compute code quality metrics
`ragix_models_list`	List available Ollama models
`ragix_model_info`	Get detailed model information
`ragix_system_info`	Comprehensive system introspection

Example: System Info

result = ragix_system_info()
# Returns: platform, cpu, memory, gpu (CUDA), disk, ollama status

Example: AST Scan

result = ragix_ast_scan("/path/to/project", language="auto")
# Returns: symbols, summary (classes, methods, functions)

2. Parallel KOAS Execution

The koas_run tool now supports parallel kernel execution:

# Sequential (default)
koas_run(workspace, stage=0)  # ~5-10s for 60K LOC

# Parallel (new)
koas_run(workspace, stage=0, parallel=True, workers=4)  # ~3.4s for 60K LOC

Performance gains:

Stage 1 (Data Collection): 2-3x faster
Stage 2 (Analysis): ~2x faster with batching
Stage 3 (Reporting): Unchanged (sequential for consistency)

3. French i18n Corrections

Fixed 50+ translation strings for proper UTF-8 diacritics in French reports:

Before	After
Methodologie	Méthodologie
Synthese Executive	Synthèse Exécutive
Complexite	Complexité
Indice de Maintenabilite	Indice de Maintenabilité
Évaluation des Risques	Évaluation des Risques

Files updated:

ragix_kernels/audit/report/i18n.py
ragix_kernels/audit/report/templates.py
ragix_kernels/audit/section_drift.py

4. Claude Code Slash Commands

New and updated commands:

Command	Description
`/koas-audit`	Full audit with `--parallel` option
`/ragix-system`	System introspection for deployment
`/ragix-models`	Model management and selection

Technical Details

New MCP Tool Signatures

# AST Analysis
def ragix_ast_scan(
    path: str,
    language: str = "auto",
    include_private: bool = False,
) -> Dict[str, Any]: ...

def ragix_ast_metrics(
    path: str,
    language: str = "auto",
) -> Dict[str, Any]: ...

# Model Management
def ragix_models_list() -> Dict[str, Any]: ...
def ragix_model_info(model: str) -> Dict[str, Any]: ...

# System Info
def ragix_system_info() -> Dict[str, Any]: ...

KOAS Run Enhanced Signature

def koas_run(
    workspace: str,
    stage: int = 0,
    kernels: str = "",
    parallel: bool = False,  # NEW
    workers: int = 4,        # NEW
) -> Dict[str, Any]:
    # Returns: status, stages_run, results, report_path,
    #          execution_mode, workers, duration_seconds

Test Coverage

New test file: tests/test_mcp_server.py

18 tests covering:

AST scan single file and directory
Private symbol filtering
Non-existent path handling
Metrics computation
Model listing (mocked Ollama)
Model info retrieval
System info structure
KOAS parallel parameter validation
Tool availability checks (core, KOAS, v0.8.0)

pytest tests/test_mcp_server.py -v
# Result: 18 passed in 4.34s

Performance Benchmarks

IOWIZME Audit (Java, 60K LOC)

Metric	Value
Total Files	806
Total Classes	582
Total Methods	2,704
Lines of Code	60,157
Audit Time (parallel)	3.4 seconds
Maintainability Index	100/100 (Grade A)
Technical Debt	0.0 days

Throughput Estimates

Project Size	Time (parallel)	Hourly Rate
10K LOC	~1s	3,600/hour
60K LOC	~3-4s	900-1,200/hour
200K LOC	~10-15s	240-360/hour
1M LOC	~60s	60/hour

Installation

No new dependencies required. Existing installations update automatically:

pip install --upgrade ragix
# Or from source:
pip install -e .

Migration Notes

From v0.59.0

No breaking changes
All existing MCP tools continue to work
KOAS workspaces are fully compatible
New tools available immediately after upgrade

For MCP Clients

Update tool invocations to use new features:

// Old
{"tool": "koas_run", "workspace": "/path"}

// New (with parallel)
{"tool": "koas_run", "workspace": "/path", "parallel": true, "workers": 4}

Known Issues

None reported.

What's Next (v0.61.0)

Potential areas for future improvement:

GPU acceleration for AST parsing (CUDA)
Streaming audit progress via MCP
Multi-repository batch auditing
Real-time audit dashboard

Video Demonstration

Watch the RAGIX demo showcasing key features:
https://www.youtube.com/watch?v=vDHI70ZPnDE

Industrial Applications

RAGIX v0.60.0 is ready for:

Enterprise Code Audits: Thousands of files, millions of classes
MCO (Maintenance) Assessments: Technical debt quantification
Continuous Quality Monitoring: Regular codebase reviews
Documentation Gap Analysis: Code-spec drift detection

With proper GPU and CPU resources, organizations can audit:

3-20 codebases per hour (depending on size)
Hundreds of projects per day
Full deterministic, statistical, and AI-powered analysis

Contributors

Olivier Vitrac — Architecture, implementation, testing

Generated by KOAS (Kernel-Orchestrated Audit System)
RAGIX — Retrieval-Augmented Generative Interactive eXecution Agent

Assets 2

12 Dec 14:00

ovitrac

v0.56.0

55027b6

RAGIX 0.56.0 – Improved Dead Code Detection

RAGIX 0.56.0 delivers improved dead code detection, enhanced partitioner UI, and all features from 0.55 including enterprise-grade code audit, codebase partitioning, and MDS graph layout.

RAGIX v0.56.0 — Enterprise Code Audit & Codebase Partitioner

This release transforms RAGIX from a development assistant into a professional code audit platform capable of analyzing enterprise Java codebases with 15,000+ classes. Key capabilities:

Codebase Partitioner — Automatic application boundary detection with D3.js force-directed visualization
Enterprise Service Detection — Support for multiple service naming conventions (SK/SC/SG, spre##, custom patterns)
MDS Graph Layout — Precomputed positions using eigendecomposition for large graphs
Multi-Module Maven Support — Auto-detect complex project structures
Code Tracker — Outliers, complexity hotspots, dead code, coupling issues
Project RAG — ChromaDB vector store with concept exploration

What's New in v0.56.0

Category	Feature	Description
Partitioner	Force-Directed Graph	D3.js physics simulation with partition clustering
Partitioner	MDS Layout	Eigendecomposition-based positioning for <500 nodes
Partitioner	Partition-Based Layout	O(n) circular layout for >500 nodes (17K+ supported)
Partitioner	Export System	SVG, PNG, JSON, CSV formats
Audit	Service Pattern Presets	IOWIZME (SK/SC/SG), Enterprise (spre##), Combined
Audit	Multi-Module Maven	Auto-detect `app-*/src/main/java/` structures
Audit	Risk Analysis	Timeline-based risk scoring with configurable weights
Audit	Service Lifecycle	NEW/ACTIVE/MATURE/LEGACY categorization
Code Tracker	Complexity Hotspots	Identify methods with CC > threshold
Code Tracker	Dead Code Detection	Isolated class detection (no callers AND no callees)
Code Tracker	Coupling Issues	Ca/Ce/Instability metrics per package
Project RAG	Concept Explorer	Dual-view (files + D3.js graph)
Project RAG	Knowledge Summary	LLM-powered concept summarization
UI	Audit Settings	Configurable thresholds, weights, service patterns
UI	Label Visibility	All node labels visible at max zoom
UI	Line Navigation	Smooth scrolling in code preview

Version History:

v0.33 — Agentic reasoning, threads, RAG router
v0.35 — Project RAG with concept exploration
v0.40 — Code audit capabilities, service detection
v0.50 — Code tracker, RAG stats integration
v0.51 — Project discovery, type safety fixes
v0.55 — Codebase partitioner, MDS layout, enterprise patterns
v0.56 — Improved dead code detection (isolated classes only), partitioner UI

Codebase Partitioner (New in v0.55)

The Partitioner analyzes dependency graphs to automatically identify application boundaries within monolithic codebases — essential for modernization and refactoring planning.

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Codebase Partitioner                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Configuration          Visualization         Export            │
│  ┌─────────────┐       ┌─────────────┐      ┌─────────────┐    │
│  │ Application │       │ D3.js Force │      │ SVG / PNG   │    │
│  │ Patterns    │  ───► │ Directed    │ ───► │ JSON / CSV  │    │
│  │ (pkg/class/ │       │ Graph       │      │ XLSX        │    │
│  │  keyword)   │       │             │      │             │    │
│  └─────────────┘       └─────────────┘      └─────────────┘    │
│        │                     │                                  │
│        ▼                     ▼                                  │
│  ┌─────────────┐       ┌─────────────┐                         │
│  │ Fingerprint │       │ MDS / Part. │                         │
│  │ Matching    │       │ Layout      │                         │
│  └─────────────┘       └─────────────┘                         │
│        │                     │                                  │
│        ▼                     ▼                                  │
│  ┌─────────────┐       ┌─────────────┐                         │
│  │ Graph       │       │ Auto-Stop   │                         │
│  │ Propagation │       │ Simulation  │                         │
│  └─────────────┘       └─────────────┘                         │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Fingerprint Matching

Classes are assigned to partitions based on configurable patterns:

# Example configuration
{
    "applications": [
        {
            "name": "APP_A",
            "color": "#4fc3f7",
            "patterns": {
                "packages": ["com.company.app_a"],
                "classes": ["*ServiceA*", "*ControllerA*"],
                "keywords": ["module_a", "feature_a"]
            }
        },
        {
            "name": "APP_B",
            "color": "#81c784",
            "patterns": {
                "packages": ["com.company.app_b"],
                "classes": ["*ServiceB*"],
                "keywords": ["module_b"]
            }
        }
    ],
    "shared_patterns": {
        "packages": ["com.company.common", "com.company.util"],
        "classes": ["*Utils*", "*Helper*", "*Constants*"]
    }
}

Graph Propagation

Unassigned classes are propagated based on dependency relationships:

Fingerprint matching — Direct pattern match → High confidence (0.9)
Import propagation — Majority of imports from partition → Medium confidence (0.7)
Reverse propagation — Used by partition classes → Low confidence (0.5)

Dead Code Detection

Classes are classified as DEAD_CODE only when they are completely isolated:

DEAD_CODE criteria:
├── No incoming dependencies (nobody calls this class)
├── No outgoing dependencies (this class doesn't call anything)
└── Not an entry point pattern (*Controller, *Test, *Main, etc.)

Why this approach?

In Java/Spring applications, many classes appear to have no callers in static analysis but are actually used via:

Dependency Injection — Spring wires @Service, @Repository, @Component via reflection
JPA/ORM — Entities are loaded by Hibernate, not direct calls
Event listeners — @EventListener methods are invoked by the framework
Scheduled tasks — @Scheduled methods run via Spring scheduler

A class that calls other classes but has no callers is likely still active (loaded via reflection). Only classes with no connections at all are truly dead code.

Condition	Classification
Has callers	LIVE
No callers, but calls others	LIVE (likely DI/reflection)
No callers AND no callees	DEAD_CODE
Entry point pattern (Controller, Test)	LIVE (always)

MDS Layout Algorithm

For graphs with <500 nodes, we use Classical Multidimensional Scaling:

def _mds_layout(node_ids, width, height):
    """
    Classical MDS using eigendecomposition.

    1. Build shortest-path distance matrix (Floyd-Warshall for small graphs)
    2. Double-center the squared distance matrix
    3. Extract top 2 eigenvectors
    4. Scale to viewport dimensions
    """
    n = len(node_ids)

    # Build adjacency and compute shortest paths
    D = floyd_warshall(adjacency_matrix)

    # Double centering: B = -0.5 * J * D² * J where J = I - 1/n * 11'
    D_sq = D ** 2
    row_mean = D_sq.mean(axis=1, keepdims=True)
    col_mean = D_sq.mean(axis=0, keepdims=True)
    grand_mean = D_sq.mean()
    B = -0.5 * (D_sq - row_mean - col_mean + grand_mean)

    # Eigendecomposition
    eigenvalues, eigenvectors = np.linalg.eigh(B)
    idx = np.argsort(eigenvalues)[::-1]

    # Extract top 2 dimensions
    coords = eigenvectors[:, idx[:2]] * np.sqrt(eigenvalues[idx[:2]])

    # Scale to viewport
    return scale_to_viewport(coords, width, height)

Partition-Based Layout (Large Graphs)

For graphs with >500 nodes (like enterprise codebases with 17K+ classes), we use a fast partition-based circular layout:

def _partition_based_layout(node_ids, width, height):
    """
    O(n) layout using partition clustering.

    1. Group nodes by partition assignment
    2. Arrange partitions in a circle
    3. Place nodes in spiral pattern within partition sector
    """
    # Group by partition
    partition_groups = defaultdict(list)
    for node_id in node_ids:
        partition = assignments.get(node_id, "UNKNOWN")
        partition_groups[partition].append(node_id)

    # Arrange partitions in circle
    center_x, center_y = width / 2, height / 2
    radius = min(width, height) * 0.35

    positions = {}
    for i, (partition, nodes) in enumerate(partition_groups.items()):
        # Partition center on circle
        angle = 2 * pi * i / len(partition_groups)
        px = center_x + radius * cos(angle)
        py = center_y + radius * sin(angle)

        # Spiral arrangement within partition
        for j, node_id in enumerate(nodes):
            r = 20 + j * 3  # Expanding spiral
            a = angle + j * 0.3
            positions[node_id] = (px + r * cos(a), py + r * sin(a))

    return positions

Force-Directed Visualization

The D3.js visualization includes:

Control	Function
Zoom/Pan	Mouse wheel zoom, drag to pan
Force Sliders	Repulsion, Link Distance, Link Strength, Center Gravity, Collision
Force Presets	Separated, Clustered, Balanced configurations
Labels Toggle	Show/hide node labels
Connections Toggle	...

Assets 2

11 Dec 15:04

ovitrac

v0.55.0

d807069

RAGIX 0.55.0 – Contractive Reasoning & Agentic Profiles

RAGIX 0.55.0 is a major milestone delivering enterprise-grade code audit, codebase partitioning, MDS graph layout, and multi-module Maven support for large-scale Java applications.

RAGIX v0.55.0 — Enterprise Code Audit & Codebase Partitioner

This release transforms RAGIX from a development assistant into a professional code audit platform capable of analyzing enterprise Java codebases with 15,000+ classes. Key capabilities:

Codebase Partitioner — Automatic application boundary detection with D3.js force-directed visualization
Enterprise Service Detection — Support for multiple service naming conventions (SK/SC/SG, spre##, custom patterns)
MDS Graph Layout — Precomputed positions using eigendecomposition for large graphs
Multi-Module Maven Support — Auto-detect complex project structures
Code Tracker — Outliers, complexity hotspots, dead code, coupling issues
Project RAG — ChromaDB vector store with concept exploration

What's New in v0.55.0

Category	Feature	Description
Partitioner	Force-Directed Graph	D3.js physics simulation with partition clustering
Partitioner	MDS Layout	Eigendecomposition-based positioning for <500 nodes
Partitioner	Partition-Based Layout	O(n) circular layout for >500 nodes (17K+ supported)
Partitioner	Export System	SVG, PNG, JSON, CSV formats
Audit	Service Pattern Presets	IOWIZME (SK/SC/SG), Enterprise (spre##), Combined
Audit	Multi-Module Maven	Auto-detect `app-*/src/main/java/` structures
Audit	Risk Analysis	Timeline-based risk scoring with configurable weights
Audit	Service Lifecycle	NEW/ACTIVE/MATURE/LEGACY categorization
Code Tracker	Complexity Hotspots	Identify methods with CC > threshold
Code Tracker	Dead Code Detection	Static reachability analysis
Code Tracker	Coupling Issues	Ca/Ce/Instability metrics per package
Project RAG	Concept Explorer	Dual-view (files + D3.js graph)
Project RAG	Knowledge Summary	LLM-powered concept summarization
UI	Audit Settings	Configurable thresholds, weights, service patterns
UI	Label Visibility	All node labels visible at max zoom
UI	Line Navigation	Smooth scrolling in code preview

Version History:

v0.33 — Agentic reasoning, threads, RAG router
v0.35 — Project RAG with concept exploration
v0.40 — Code audit capabilities, service detection
v0.50 — Code tracker, RAG stats integration
v0.51 — Project discovery, type safety fixes
v0.55 — Codebase partitioner, MDS layout, enterprise patterns

Codebase Partitioner (New in v0.55)

The Partitioner analyzes dependency graphs to automatically identify application boundaries within monolithic codebases — essential for modernization and refactoring planning.

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Codebase Partitioner                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Configuration          Visualization         Export            │
│  ┌─────────────┐       ┌─────────────┐      ┌─────────────┐    │
│  │ Application │       │ D3.js Force │      │ SVG / PNG   │    │
│  │ Patterns    │  ───► │ Directed    │ ───► │ JSON / CSV  │    │
│  │ (pkg/class/ │       │ Graph       │      │ XLSX        │    │
│  │  keyword)   │       │             │      │             │    │
│  └─────────────┘       └─────────────┘      └─────────────┘    │
│        │                     │                                  │
│        ▼                     ▼                                  │
│  ┌─────────────┐       ┌─────────────┐                         │
│  │ Fingerprint │       │ MDS / Part. │                         │
│  │ Matching    │       │ Layout      │                         │
│  └─────────────┘       └─────────────┘                         │
│        │                     │                                  │
│        ▼                     ▼                                  │
│  ┌─────────────┐       ┌─────────────┐                         │
│  │ Graph       │       │ Auto-Stop   │                         │
│  │ Propagation │       │ Simulation  │                         │
│  └─────────────┘       └─────────────┘                         │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

Fingerprint Matching

Classes are assigned to partitions based on configurable patterns:

# Example configuration
{
    "applications": [
        {
            "name": "APP_A",
            "color": "#4fc3f7",
            "patterns": {
                "packages": ["com.company.app_a"],
                "classes": ["*ServiceA*", "*ControllerA*"],
                "keywords": ["module_a", "feature_a"]
            }
        },
        {
            "name": "APP_B",
            "color": "#81c784",
            "patterns": {
                "packages": ["com.company.app_b"],
                "classes": ["*ServiceB*"],
                "keywords": ["module_b"]
            }
        }
    ],
    "shared_patterns": {
        "packages": ["com.company.common", "com.company.util"],
        "classes": ["*Utils*", "*Helper*", "*Constants*"]
    }
}

Graph Propagation

Unassigned classes are propagated based on dependency relationships:

Fingerprint matching — Direct pattern match → High confidence (0.9)
Import propagation — Majority of imports from partition → Medium confidence (0.7)
Reverse propagation — Used by partition classes → Low confidence (0.5)

MDS Layout Algorithm

For graphs with <500 nodes, we use Classical Multidimensional Scaling:

def _mds_layout(node_ids, width, height):
    """
    Classical MDS using eigendecomposition.

    1. Build shortest-path distance matrix (Floyd-Warshall for small graphs)
    2. Double-center the squared distance matrix
    3. Extract top 2 eigenvectors
    4. Scale to viewport dimensions
    """
    n = len(node_ids)

    # Build adjacency and compute shortest paths
    D = floyd_warshall(adjacency_matrix)

    # Double centering: B = -0.5 * J * D² * J where J = I - 1/n * 11'
    D_sq = D ** 2
    row_mean = D_sq.mean(axis=1, keepdims=True)
    col_mean = D_sq.mean(axis=0, keepdims=True)
    grand_mean = D_sq.mean()
    B = -0.5 * (D_sq - row_mean - col_mean + grand_mean)

    # Eigendecomposition
    eigenvalues, eigenvectors = np.linalg.eigh(B)
    idx = np.argsort(eigenvalues)[::-1]

    # Extract top 2 dimensions
    coords = eigenvectors[:, idx[:2]] * np.sqrt(eigenvalues[idx[:2]])

    # Scale to viewport
    return scale_to_viewport(coords, width, height)

Partition-Based Layout (Large Graphs)

For graphs with >500 nodes (like enterprise codebases with 17K+ classes), we use a fast partition-based circular layout:

def _partition_based_layout(node_ids, width, height):
    """
    O(n) layout using partition clustering.

    1. Group nodes by partition assignment
    2. Arrange partitions in a circle
    3. Place nodes in spiral pattern within partition sector
    """
    # Group by partition
    partition_groups = defaultdict(list)
    for node_id in node_ids:
        partition = assignments.get(node_id, "UNKNOWN")
        partition_groups[partition].append(node_id)

    # Arrange partitions in circle
    center_x, center_y = width / 2, height / 2
    radius = min(width, height) * 0.35

    positions = {}
    for i, (partition, nodes) in enumerate(partition_groups.items()):
        # Partition center on circle
        angle = 2 * pi * i / len(partition_groups)
        px = center_x + radius * cos(angle)
        py = center_y + radius * sin(angle)

        # Spiral arrangement within partition
        for j, node_id in enumerate(nodes):
            r = 20 + j * 3  # Expanding spiral
            a = angle + j * 0.3
            positions[node_id] = (px + r * cos(a), py + r * sin(a))

    return positions

Force-Directed Visualization

The D3.js visualization includes:

Control	Function
Zoom/Pan	Mouse wheel zoom, drag to pan
Force Sliders	Repulsion, Link Distance, Link Strength, Center Gravity, Collision
Force Presets	Separated, Clustered, Balanced configurations
Labels Toggle	Show/hide node labels
Connections Toggle	Show/hide cross-partition edges
Auto-Stop	Simulation stabilizes with precomputed positions

Export Formats

Format	Content
SVG	Vector graphics for documentation
PNG	High-resolution raster (2x resolution)
JSON	Full metadata: FQN, partition, confidence, evidence, LOC
CSV	Spreadsheet-ready format
XLSX	Excel workbook with multiple sheets

API Endpoints

POST /api/ast/partition          # Run partition analysis
GET  /api/ast/partition/presets  # Get preset configurations
GET  /api/ast/partition/export   # Export results (format query param)
GET  /api/ast/partition/status   # Check partitioner availability

Enterprise Service Detection

RAGIX v0.55 supports multiple service naming conventions for enterprise Java applications:

Supported Patterns

Pattern Type	Examples	Use Case
SK/SC/SG	`SK01`, `SC04`, `SG02`	Service Keys, Screen Codes, General Services
spre##	`spre28ws`, `spre13`, `sprebpm`	Enterprise web services, JMS handlers
s[Action]	`sAffecterTache`, `sCloturerIncident`	Task operations
Custom	User-defined regex patterns	Project-specific conventions

Detection Sources

# Annotation pattern...

Assets 2

06 Dec 20:04

ovitrac

v0.33.0

5f3b5f3

RAGIX 0.33.0 – Contractive Reasoning & Agentic Profiles

RAGIX 0.33.0 is the largest leap forward since the project began.
It delivers a production-ready agentic reasoning framework, Claude Code-style shell execution, hybrid RAG retrieval, and a full graphical web interface.

🚀 RAGIX v0.33.0 — The Agentic Reasoning Platform

This release marks RAGIX's transition from a Unix-only automation agent (0.11) into a complete AI-powered development assistant with:

Reflective Reasoning Graph (v0.30) — Production-ready multi-node reasoning
Claude Code-style Shell Sandbox — Safe command execution with audit logging
Hybrid RAG — BM25 + Vector search with multiple fusion strategies
AST Analysis — Python/Java code understanding
RAGIX-web — Full graphical interface

📋 What's New in v0.33.0

Category	Feature	Description
Web UI	RAG Router	`/api/rag` endpoints for index management
Web UI	Threads Router	`/api/threads` for multi-conversation support
Web UI	Cancellation	Interrupt long-running LLM operations
Web UI	RAG Context Display	Show retrieved documents in chat
Core	Session Management	Full session lifecycle with memory
Core	Global Context	Inject persistent context across messages
Research	Contractive Reasoning	Entropy-based tree decomposition
Research	Peer Review	Multi-model answer validation

Version History:

v0.30 — Reasoning Graph architecture
v0.31 — Agent specialization (code/doc/git/test)
v0.32 — Hybrid RAG, AST analysis
v0.33 — Sessions, threads, RAG router, experimental reasoning

✨ Core Architecture (Production)

1. Reflective Reasoning Graph (reasoning_v30/)

The production reasoning engine implements a state machine graph with specialized nodes:

CLASSIFY → DIRECT_EXEC (bypass/simple)
    ↓
   PLAN → EXECUTE → REFLECT → VERIFY → RESPOND
              ↑         ↓
              └─────────┘ (retry loop)

Node	Function
CLASSIFY	Route by task complexity: BYPASS / SIMPLE / MODERATE / COMPLEX
DIRECT_EXEC	Handle simple tasks without formal planning
PLAN	Generate structured execution plans
EXECUTE	Execute plan steps with tool calls
REFLECT	Diagnose failures, generate revised plans
VERIFY	Validate complex task results
RESPOND	Format final response, emit events

Key features:

Full execution trace for debugging
Event emission for experience corpus
Configurable iteration limits
Tool result integration

2. Shell Sandbox (Claude Code-style)

from ragix_core.tools_shell import ShellSandbox

sandbox = ShellSandbox(
    root="/workspace",
    dry_run=False,
    profile="dev",
    allow_git_destructive=False
)

result = sandbox.run("grep -r 'def main' .")

Safety features:

Confines execution to sandbox root
Hard denylist (DANGEROUS_PATTERNS)
Blocks destructive git commands by default
Full command logging with timestamps
Dry-run mode for testing

3. Hybrid RAG Retrieval

from ragix_core.hybrid_search import HybridSearchEngine, FusionStrategy

engine = HybridSearchEngine(
    bm25_index=bm25_idx,
    vector_index=vec_idx,
    fusion_strategy=FusionStrategy.RRF,  # Reciprocal Rank Fusion
)

results = engine.search("authentication middleware", top_k=10)

Fusion strategies:

Strategy	Description
`RRF`	Reciprocal Rank Fusion (default)
`WEIGHTED`	Weighted score combination
`INTERLEAVE`	Round-robin interleaving
`BM25_RERANK`	Vector search, BM25 rerank
`VECTOR_RERANK`	BM25 search, vector rerank

4. AST Analysis (Python + Java)

from ragix_core.ast_python import PythonASTBackend

backend = PythonASTBackend()
ast_tree = backend.parse_file(Path("src/main.py"))

# Extract classes, functions, imports, decorators, type annotations
for node in ast_tree.children:
    print(f"{node.node_type}: {node.name}")

Extracts:

Classes with inheritance hierarchy
Functions and methods
Imports (import and from...import)
Decorators
Type annotations
Docstrings
Module-level constants

✨ RAGIX-web: Full Graphical Interface

RAGIX-web is the flagship interface — a production-ready FastAPI application with WebSocket real-time communication.

Architecture

ragix_web/
├── server.py              # FastAPI server (50k+ lines)
├── routers/               # Modular API endpoints
│   ├── agents.py          # Agent configuration & personas
│   ├── reasoning.py       # Reasoning graph state & control
│   ├── rag.py             # RAG index management (v0.33)
│   ├── sessions.py        # Session lifecycle management
│   ├── memory.py          # Message history & context
│   ├── context.py         # User context injection
│   ├── threads.py         # Multi-thread conversations (v0.33)
│   └── logs.py            # Audit log access
│
└── static/                # Frontend application
    ├── app.js             # Main WebSocket client
    ├── workflow.js        # D3.js reasoning graph visualization
    ├── diff.js            # Side-by-side diff viewer
    ├── files.js           # File browser
    ├── logs.js            # Log viewer
    └── js/
        ├── dependency_explorer.js  # Force-directed dependency graph
        ├── virtual_fs.js           # In-browser filesystem
        ├── browser_tools.js        # Browser-based tools
        └── wasp_runtime.js         # WASP workflow runtime

REST API Endpoints

Router	Prefix	Features
Sessions	`/api/sessions`	Create/list/delete sessions, model selection
Memory	`/api/sessions/{id}/memory`	View/edit/delete message history
Context	`/api/sessions/{id}/context`	Global context injection
Agents	`/api/agents`	Agent config, model assignment, personas
Reasoning	`/api/reasoning`	Graph state, step control, experience corpus
RAG	`/api/rag`	Index status, document upload, enable/disable
Threads	`/api/threads`	Multi-thread management, thread switching
Logs	`/api/logs`	Audit log browsing, command history

WebSocket Real-Time Features

// Connect to session
ws = new WebSocket(`ws://localhost:8000/ws/chat/${sessionId}`);

// Message types
- 'user_message'   // User input
- 'agent_message'  // Agent response
- 'thinking'       // Progress indicator (cancellable)
- 'rag_context'    // RAG retrieval notification
- 'cancel_ack'     // Cancellation confirmed
- 'status'         // Connection status

Interactive Visualizations

Workflow Visualizer (D3.js):

Force-directed graph of reasoning nodes
Real-time status colors (pending/running/completed/failed)
Zoom/pan navigation
Node inspection on click

Diff Viewer:

Split and unified view modes
Accept/reject changes
Syntax highlighting
Multi-file navigation

Dependency Explorer:

Package clustering
Edge bundling for clarity
Search and filter
Export to SVG/PNG

Optional Integrations

Integration	Availability	Purpose
AST Analysis	Optional	Python/Java code graphs, metrics
Maven Parser	Optional	POM.xml analysis, dependency conflicts
SonarQube	Optional	Code quality reports
Prompt Database	Optional	Reusable prompt templates
Workflow Templates	Optional	Predefined task workflows

Security Model

Launch Directory Confinement: Sandbox restricted to server start directory
CORS: Enabled for local development (localhost only)
Session Isolation: Each session has isolated state
Cancellation Support: Background tasks can be interrupted

Quick Start

# Start the web server
ragix-web

# With custom port and sandbox
ragix-web --port 8080 --sandbox ./my-project

# Open browser
http://localhost:8000

✨ Unix-RAG Agent

The original RAGIX pattern — lightweight Unix-based retrieval with LLM orchestration:

from ragix_unix import UnixRAGAgent

agent = UnixRAGAgent(
    llm=ollama_llm,
    sandbox=ShellSandbox(root="./project"),
)

# Uses grep, find, sed, awk for retrieval — no vector DB required
response = agent.run("Find all functions that handle authentication")

Unix-RAG Tools:

Tool	Command	Purpose
`grep`	`grep -r -n`	Content search with line numbers
`find`	`find -name`	File discovery by pattern
`head/tail`	`head -n`, `tail -n`	View file portions
`sed`	`sed -n 'X,Yp'`	Extract line ranges
`wc`	`wc -l`	Count lines
`awk`	`awk '{...}'`	Field extraction

Key advantages:

Zero-setup (no embedding models, no vector DB)
Works on any Unix system
Predictable, auditable retrieval
Low memory footprint

✨ Agent Framework

Specialized Agents

Agent	Purpose
`code_agent`	Code generation, refactoring, bug fixing
`doc_agent`	Documentation generation and analysis
`git_agent`	Git operations, commit analysis
`test_agent`	Test generation and execution

Agent Configuration

from ragix_core.agent_config import AgentConfig

config = AgentConfig(
    model="mistral:7b-instruct",
    max_iterations=10,
    reflection_enabled=True,
    experience_corpus_path="./experience",
)

Experience Corpus

The system learns from past executions:

from ragix_core.experience_corpus import ExperienceCorpus

corpus = ExperienceCorpus("./experience")
similar = corpus.find_similar(goal="implement authentication", top_k=3)

✨ CLI Improvements

# Run reasoning on a goal
ragix reason "Implement user authentication with JWT"

# Interactive shell mode
ragix shell --sandbox /workspace

# Profile a model
...

Assets 2

28 Nov 17:11

ovitrac

v0.11.0

0096fd5

RAGIX v0.11.1

RAGIX Release v0.11.1

Build: 202511281400
Date: 2025-11-28

1. Overview

Version 0.20.0 marks a major leap forward for RAGIX, evolving it from a development assistant into a production-ready, multi-agent orchestration platform. This release introduces a powerful AST-based code analysis engine, a comprehensive Web UI, and a full suite of documentation, solidifying its position as a sovereign, local-first tool for professional software engineering.

2. 🚀 Major Features & Capabilities

This release is packed with new, deeply integrated capabilities that provide a powerful and cohesive experience.

2.1. Advanced AST Code Analysis

RAGIX now parses your entire codebase (Python & Java) into an Abstract Syntax Tree (AST), enabling deep, structural analysis and visualization.

Key Features: Dependency graph generation, cycle detection, code metrics (cyclomatic complexity, technical debt), and an interactive query language.
Example (ragix-ast CLI): Find all classes that extend BaseService and are decorated with @Transactional.
```
ragix-ast search ./src "type:class extends:BaseService @Transactional"
```

2.2. Multi-Agent Orchestration

Define, execute, and stream complex workflows with a dependency-aware graph executor.

Key Features: Pre-built templates for common tasks (bug_fix, code_review, feature_addition), parallel execution, and a clear separation of Planner, Worker, and Verifier agents.

Example (Python):

from ragix_core import get_template_manager

manager = get_template_manager()
graph = manager.instantiate("bug_fix", {
    "bug_description": "TypeError in handler.py",
})
# ... then run with GraphExecutor

2.3. Hybrid Search Engine

Combine the best of keyword-based (BM25) and semantic (Vector) search for highly accurate code retrieval.

Key Features: Multiple fusion strategies (RRF, Weighted, Interleave), clear source attribution for results, and a simple API.

2.4. Flexible LLM Backends

Choose the right LLM for the job, with a clear distinction between sovereign and cloud-based models.

Sovereign (Default): 🟢 Ollama. 100% local, private, and free. Recommended for sensitive codebases.
Cloud-Based: 🔴 Claude & OpenAI. Higher reasoning quality at the cost of sending data to third-party APIs.

2.5. Production-Grade Infrastructure

Monitoring: Health checks for system components (/api/health).
Resilience: Built-in patterns like CircuitBreaker and retry_async for robust tool execution.
Caching: In-memory and disk-based caching for LLM responses and tool calls to improve performance.

3. 💻 Developer Experience & Usability

3.1. Comprehensive Documentation Suite

A full suite of documentation has been created to make RAGIX accessible and easy to learn.

Document	Location	Description
CLI Guide	`docs/CLI_GUIDE.md`	A complete reference for all `ragix-*` commands.
AST Guide	`docs/AST_GUIDE.md`	A deep dive into code analysis with `ragix-ast`.
API Reference	`docs/API_REFERENCE.md`	REST API documentation for the `ragix-web` server.
Architecture	`docs/ARCHITECTURE.md`	An overview of the system architecture.
Playbook Guide	`docs/PLAYBOOK_GUIDE.md`	How to write `ragix-batch` automation playbooks.

3.2. New Web UI

A new, comprehensive Web UI (ragix-web) provides a graphical interface for:

Interactive agent chat.
Live AST visualizations (dependency graphs, DSM matrices, radial explorers).
Session management and log viewing.

3.3. Project Reorganization

The project root has been cleaned significantly.
Old development and planning documents are now in docs/archive/.
Internal technical notes are consolidated in docs/developer/.
Every project folder now contains a README.md.

4. 🐞 Bug Fixes

Web UI: Fixed a critical AttributeError on the /api/agents/config endpoint that caused a 500 Internal Server Error.
Numerous other minor stability improvements.

Assets 2

25 Nov 20:10

ovitrac

v0.7.0

8d3d0c6

RAGIX v0.7.0 - Sovereign Multi-Agent Platform

What's New

🚀 Launcher & Web GUI

./launch_ragix.sh – One-command setup with conda
ragix_app.py – Streamlit dashboard at http://localhost:8501

🤖 Multi-Agent Workflows

8 built-in templates: bug_fix, feature_addition, code_review, and more
Graph-based execution with explicit dependencies
Streaming events for real-time progress and status updates

🔍 Hybrid Search

BM25 keyword + vector semantic search pipeline
5 fusion strategies (RRF, weighted, and others) for flexible ranking
Code-aware tokenization optimized for repositories

🔒 Sovereignty

🟢 Ollama: 100% local, air-gapped capable
🔴 Claude / OpenAI: optional cloud backends with explicit warnings

Quick Start

./launch_ragix.sh

./launch_ragix.sh gui

🤖🟢 All features remain 100% sovereign (local-first)

Enjoy sovereignty. Olivier Vitrac, PhD, HDR

Assets 2

Releases: ovitrac/RAGIX

RAGIX 0.60.0 – Contractive Reasoning & Agentic Profiles

RAGIX v0.60.0 Release Notes

Overview

Key Features

1. MCP Server v0.8.0 (22 Tools Total)

2. Parallel KOAS Execution

3. French i18n Corrections

4. Claude Code Slash Commands

Technical Details

New MCP Tool Signatures

KOAS Run Enhanced Signature

Test Coverage

Performance Benchmarks

IOWIZME Audit (Java, 60K LOC)

Throughput Estimates

Installation

Migration Notes

From v0.59.0

For MCP Clients

Known Issues

What's Next (v0.61.0)

Video Demonstration

Industrial Applications

Contributors

Uh oh!

RAGIX 0.56.0 – Improved Dead Code Detection

RAGIX v0.56.0 — Enterprise Code Audit & Codebase Partitioner

What's New in v0.56.0

Codebase Partitioner (New in v0.55)

Architecture

Fingerprint Matching

Graph Propagation

Dead Code Detection

MDS Layout Algorithm

Partition-Based Layout (Large Graphs)

Force-Directed Visualization

Uh oh!

RAGIX 0.55.0 – Contractive Reasoning & Agentic Profiles

RAGIX v0.55.0 — Enterprise Code Audit & Codebase Partitioner

What's New in v0.55.0

Codebase Partitioner (New in v0.55)

Architecture

Fingerprint Matching

Graph Propagation

MDS Layout Algorithm

Partition-Based Layout (Large Graphs)

Force-Directed Visualization

Export Formats

API Endpoints

Enterprise Service Detection

Supported Patterns

Detection Sources

Uh oh!

RAGIX 0.33.0 – Contractive Reasoning & Agentic Profiles

🚀 RAGIX v0.33.0 — The Agentic Reasoning Platform

📋 What's New in v0.33.0

✨ Core Architecture (Production)

1. Reflective Reasoning Graph (reasoning_v30/)

2. Shell Sandbox (Claude Code-style)

3. Hybrid RAG Retrieval

4. AST Analysis (Python + Java)

✨ RAGIX-web: Full Graphical Interface

Architecture

REST API Endpoints

WebSocket Real-Time Features

Interactive Visualizations

Optional Integrations

Security Model

Quick Start

✨ Unix-RAG Agent

✨ Agent Framework

Specialized Agents

Agent Configuration

Experience Corpus

✨ CLI Improvements

Uh oh!

RAGIX v0.11.1

RAGIX Release v0.11.1

1. Overview