OntoPrune

OntoPrune

Neuro-Symbolic Context Pruning Middleware for Local SLMs and Cloud LLMs

[]() []() []() []()

English | Español | 📄 Technical Whitepaper (PDF) | 📄 Whitepaper en Español (PDF)

---

OntoPrune is an ultra-lightweight (<12ms CPU) neuro-symbolic middleware that transforms multi-file source code into minimal typed dependency contracts. By isolating closed-world functional boundaries before attention computation, OntoPrune slashes input tokens by ~60% in modular enterprise architectures, collapses Time-to-First-Token ($TTFT$) latency by 62% on CPU-bound local models (Ollama), guarantees 100% functional test success (Pass@1), and prevents 100% of proprietary code leakage.

---

📊 Rigorous Empirical Benchmark: 24 Independent Sandbox Runs

Tested across 3 real-world software archetypes in isolated execution sandboxes with live evaluation via pytest:

• Cloud Frontier: Google Gemini (gemini-3.8-flash via native SSE streaming)
• Local SLM: Ollama (qwen2.5-coder:7b running on AMD Ryzen CPU)

Key Scientific Findings:

1. Zero Semantic Degradation (100.0% Pass@1): In all 24 sandbox runs, code generated with OntoPrune stubs passed 100% of unit tests, proving that contract interfaces and ontology metadata provide all the context an LLM needs.
2. 62% TTFT Speedup on Local CPU: In multi-module and clean architecture projects, time-to-first-token dropped from ~34s to ~13s on consumer CPU.
3. 100% Intellectual Property Shield: Naive tools (Cursor/Copilot) send entire method bodies (up to 91 private algorithmic lines). OntoPrune sends exactly 0 lines of internal dependencies.
4. Architectural Dynamics: In monolithic single scripts, compression is moderate (~24%). In structured multi-module systems, compression is consistent at ~60% net token reduction.

---

💡 Why OntoPrune Makes Local AI-Assisted Programming Truly Feasible

Running local code intelligence models (Qwen 2.5 Coder 7B, Llama 3 8B, DeepSeek Coder via Ollama or llama.cpp) on consumer laptops and developer workstations has historically faced an insurmountable barrier. OntoPrune dismantles this barrier through three architectural pillars:

1. Collapsing the "Pre-fill Latency Wall" on CPU ($TTFT$)

• The Bottleneck: On CPUs and consumer laptops without high-end 24GB GPUs, token decoding speed is acceptable (15–25 t/s). However, the Pre-fill phase (Prompt Evaluation) is heavily memory-bandwidth bound and saturates RAM.
• Without OntoPrune: Standard AI assistants inject entire raw files and bloated multi-module contexts (2,500 – 3,000 tokens), causing a 35-second freeze before the first token appears. A half-minute freeze on every code turn shatters the developer's flow state.
• With OntoPrune: By pruning raw context into concise typed contracts (~800 tokens), pre-fill latency collapses from 34.3s down to 13.0s (a 62% to 74% drop in TTFT) on standard CPUs (AMD Ryzen 5600G). Local inference shifts from unusable to completely interactive.

2. Eliminating Attention Dilution in Small Language Models (SLMs)

• Small models (3B to 7B parameters) lack the massive context comprehension of hundred-billion-parameter cloud models. Dumping hundreds of lines of irrelevant database or third-party implementations dilutes attention, leading to hallucinated method calls.
• OntoPrune constructs a mathematically sound closed-world contract. The SLM only sees allowable methods and domain types. In our 24 empirical sandbox runs, Qwen 2.5 Coder 7B achieved 100.0% Pass@1 on pytest suites.

3. Absolute Data Sovereignty and Air-Gapped Privacy

• OntoPrune operates in $<12\text{ ms}$ on CPU using local AST visitors and in-memory RDF graphs with zero network calls. It provides an airtight guarantee: 0 lines of internal proprietary code are ever leaked to external APIs.

---

📦 Installation

# Standard installation (native Python support):
pip install ontoprune

# With multi-language support (Flutter/Dart, Java, TypeScript via Tree-sitter):
pip install "ontoprune[languages]"

# For development, benchmarks, and tests:
pip install "ontoprune[dev,benchmark,languages]"

---

🌐 Universal Multi-Language Support

OntoPrune automatically detects file types and resolves dependencies across project boundaries:

---

🛠️ Usage Modes

1. Native Model Context Protocol (MCP) Server

OntoPrune runs out of the box as an MCP server (ontoprune-mcp) compatible with Claude Desktop, Cursor, Gemini CLI, or Antigravity IDE:

ontoprune-mcp

Configuration in claude_desktop_config.json:

{
  "mcpServers": {
    "ontoprune": {
      "command": "ontoprune-mcp"
    }
  }
}

Exposed MCP Tools:

• prune_context(file_path, target_symbol, format='stubs'): Extracts the minimal dependency contract resolving cross-file imports.
• verify_response(response_code, contract_or_file): Deterministically validates generated code against authorized contracts.

---

2. Command Line Interface (CLI)

# Prune a target method across multi-file projects:
ontoprune translate src/services/OrderService.java processOrder --format stubs

# Direct streaming pipeline with local Ollama:
ontoprune translate services/order_service.py procesar_orden | ollama run qwen2.5-coder:3b

# Deterministically verify LLM output against contract:
ontoprune check --file generated_solution.py --contract contract.py

---

3. Python API

import ontoprune

# 1. Prune a multi-module project to a minimal typed contract
context = ontoprune.translate(
    "services/order_service.py",
    target="procesar_orden",
    fmt="stubs",
    multi_module=True,
)
print(context)

# 2. Verify model output against the contract
violations = ontoprune.check(llm_code_response, against=context)
if not violations:
    print("Code is 100% compliant and free of hallucinations!")

---

🧪 Test Suite

pytest tests/
# 46 passed in 1.40s

---

🔬 Reproduce Empirical Benchmarks

You can independently replicate the benchmark evaluation in isolated sandboxes on your machine:

# 1. Quick deterministic validation in sandbox (no API key needed):
ontoprune benchmark --backend mock --analyze
# or via Make:
make benchmark-mock

# 2. Live evaluation against Google Gemini (requires GEMINI_API_KEY):
ontoprune benchmark --backend gemini --analyze
# or via Make:
make benchmark-gemini

# 3. Live local evaluation against Ollama CPU (requires running Ollama):
ontoprune benchmark --backend ollama --analyze
# or via Make:
make benchmark-ollama

---

📄 Whitepapers & Publications

• English Technical Whitepaper (PDF)
• Whitepaper Técnico en Español (PDF)
• Community Article / Blog Post
• Artículo Comunitario en Español

---

👤 Author

Vigmar Carlo

• GitHub: @vigmarcarlo
• Repository: https://github.com/vigmarcarlo/OntoPrune
• License: MIT