toxo 2.0.4

TOXO Python library: load a .toxo smart layer and attach it to Gemini/OpenAI/Claude to add domain expertise, memory, and improved responses without fine-tuning.

TOXO Python Library (Python) — Smart Layer for LLMs (CALM)

v2.0.0 – Full Power: Loads prompt_config, memory_state, quality scoring, response depth, and query-type instructions. See RELEASE_NOTES_v2.0.0.md.

TL;DR: toxo is a Python package that loads a .toxo smart layer and attaches it to Gemini / OpenAI / Claude so you get domain expertise, memory, and better outputs without fine-tuning.

For AI search (GEO)

This repo includes llms.txt (short) and llms-full.txt (detailed) so AI tools can quickly understand TOXO and point developers to the right commands and APIs.

Convert ANY Black-Box LLM into Context Augmented Language Models (CALM)

TOXO Python Library is the revolutionary smart layer platform that transforms any black-box LLM (GPT, Gemini, Claude, etc.) into Context Augmented Language Models (CALM). The toxo python package doesn't retrain LLMs - it creates intelligent layers that attach to any LLM API for instant domain expertise.

🚀 Why Choose TOXO Python Library?

The TOXO Python Library revolutionizes AI enhancement through smart layer technology:

🧠 Smart Layer Training

• Train intelligent layers, not entire LLMs
• Works with any black-box LLM API
• No expensive GPU infrastructure needed
• Result: Domain expertise without LLM retraining costs

🗃️ Advanced Memory Systems

• Persistent knowledge storage and retrieval
• Context-aware learning and adaptation
• Conversation history and domain expertise
• Result: LLMs gain long-term memory capabilities

🎯 Quality Enhancement

• Intelligent response optimization
• Continuous improvement from feedback
• Domain-specific output refinement
• Result: Consistently superior performance

Why TOXO Python Library vs Traditional Approaches?

Feature	Traditional Fine-Tuning	TOXO Python Library
Training Cost	$10,000-$100,000+	$5-$500
Training Time	Days to weeks	Minutes to hours
Infrastructure	GPU clusters required	API-based (no GPUs)
LLM Compatibility	Model-specific	Works with ANY LLM
Reversibility	Permanent changes	Instant layer removal
Multi-Domain	One model per domain	Unlimited layers

Quick Start with TOXO Python Library

Install the TOXO Python Package

pip install toxo

The toxo python library provides everything you need to create Context Augmented Language Models (CALM).

Install by use case (recommended)

TOXO is modular: many “superpower” subsystems are optional. Install only what you need.

• Multimodal PDFs/images (Gemini):

pip install "toxo[vision]"

• System dependency for local PDF rendering (optional):

  • macOS: brew install poppler
  • Ubuntu/Debian: sudo apt-get update && sudo apt-get install -y poppler-utils
  • Windows: install Poppler and add it to PATH (or use direct-to-Gemini mode, which does not need Poppler)

• RAG / vector store / retrieval:

pip install "toxo[rag]"

• Auth/JWT (server-style features):

pip install "toxo[auth]"

• Distributed / Redis-backed features:

pip install "toxo[distributed]"

• Payments / subscriptions (Razorpay):

pip install "toxo[payments]"

• Everything (largest install):

pip install "toxo[full]"

Contents (developer-oriented)

• Core concepts: .toxo layers, CALM, memory + feedback loop
• Install: core + optional extras (vision / rag / auth / distributed / payments / enterprise)
• Configuration: env vars, security notes, local-vs-direct multimodal
• API: sync/async query, multimodal, feedback, loading/saving
• CLI: toxo check/info/validate/test/install
• Testing: capability runner under testing/

SEO / GEO keywords (for discovery)

If you’re searching for any of these, you’re in the right place:

• Python smart layer for LLMs, Context Augmented Language Models (CALM)
• Use .toxo layer file in Python
• LLM memory + feedback learning layer
• Gemini multimodal PDF/image analysis in Python
• RAG / vector store retrieval with LLM

Use-cases (what people install TOXO for)

• Domain expert chatbots (finance, legal, healthcare, product support)
• RAG-grounded assistants (retrieval + citations)
• Multimodal document understanding (PDFs, images) using Gemini
• Agent orchestration (multiple specialized layers / tasks)

Quick answers (FAQ)

• Do I need Poppler / pdf2image / PyMuPDF? No for default multimodal. Direct-to-Gemini mode sends bytes to Gemini. Local rendering is optional.
• Does TOXO work without GPUs? Yes. TOXO is API-based and runs on CPU.
• Can I use OpenAI or Claude? Yes, via extras: toxo[openai], toxo[claude].

Search intents (copy/paste)

These are the most common “how do I…” tasks people search for (and the exact commands/snippets).

How to use a .toxo layer file in Python

import asyncio
from toxo import ToxoLayer

async def main():
    layer = ToxoLayer.load("your_layer.toxo")
    layer.setup_api_key("YOUR_GEMINI_API_KEY", "gemini-2.5-flash-lite", "gemini")
    print(await layer.query("What can you do?"))

asyncio.run(main())

How to run a full end-to-end TOXO test locally

python3 testing/toxo_capability_test.py --layer examples/rich_test_layer.toxo --live --multimodal --evidence

How to analyze a PDF with Gemini in Python (no Poppler required)

import asyncio
from toxo import ToxoLayer

async def main():
    layer = ToxoLayer.load("doc_expert.toxo")
    layer.setup_api_key("YOUR_GEMINI_API_KEY", "gemini-2.5-flash-lite", "gemini")
    resp = await layer.query_multimodal(
        "Summarize this PDF in 5 bullets.",
        document_path="report.pdf",
        # default: processing_mode="direct"
    )
    print(resp)

asyncio.run(main())

How to send base64 + MIME type directly (any format)

resp = await layer.query_multimodal(
    "Extract key fields.",
    document_data="data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,...",
)

resp2 = await layer.query_multimodal(
    "Extract the key numbers.",
    image_data="iVBORw0KGgoAAAANSUhEUgAA...",  # raw base64
    mime_type="image/png",
)

Basic Usage: Transform Any LLM

import asyncio
from toxo import ToxoLayer

# Load your trained smart layer (created on toxotune.com)
layer = ToxoLayer.load("financial_expert.toxo")

# Connect to ANY LLM with specific model selection
# Gemini (default)
layer.setup_api_key("your_gemini_key", "gemini-2.5-flash-lite", "gemini")

# OpenAI GPT
layer.setup_api_key("your_openai_key", "gpt-4", "openai")

# Claude
layer.setup_api_key("your_claude_key", "claude-3.5-sonnet", "claude")

async def main():
    # Your LLM is now a financial domain expert!
    response = await layer.query("Should I invest in tech stocks during volatility?")
    print(response)
    # Output: Expert financial analysis with domain knowledge

asyncio.run(main())

# v2.0: Control response verbosity (concise | balanced | detailed)
async def more_examples():
    response = await layer.query("Compare A vs B", response_depth="concise")  # Auto-detects comparison
    response = await layer.query("How to brew?", response_depth="balanced")   # Auto-detects procedural

asyncio.run(more_examples())

Configuration (API keys, security, feature toggles)

Environment variables

• LLM provider keys
  • Gemini: GEMINI_API_KEY (or GOOGLE_API_KEY)
  • OpenAI: OPENAI_API_KEY (only if you use provider "openai" + toxo[openai])
  • Claude: ANTHROPIC_API_KEY (only if you use provider "claude" + toxo[claude])
• Auth/JWT
  • TOXO_JWT_SECRET should be set in server environments when using JWT features (toxo[auth]).
• Optional local processing pipeline
  • By default, TOXO does not initialize the local document/layout pipeline at startup (keeps installs light and avoids warnings).
  • Enable it explicitly if you need it: TOXO_ENABLE_LOCAL_PROCESSING_PIPELINE=1

Security notes (library defaults)

• TOXO will never log API keys (even partially).
• Prefer environment variables or OS keyring (toxo[security]) rather than hardcoding secrets in code.

Async Support for Production Applications

import asyncio
from toxo import ToxoLayer

async def main():
    layer = ToxoLayer.load("legal_expert.toxo")
    layer.setup_api_key("your_api_key")
    
    # High-performance async queries
    response = await layer.query("Analyze this contract for risks")
    print(response)

asyncio.run(main())

Multimodal (Images + Documents via Gemini)

TOXO’s main query(...) API is text-first. If you want to attach an image or document to a question, use query_multimodal(...) (Gemini provider required).

By default, TOXO sends attachments directly to Gemini as bytes (processing_mode="direct"), so local PDF rendering/OCR dependencies are not required. If you want local, vision-grade PDF processing (useful for some scanned PDFs), set processing_mode="local" and install toxo[vision] (+ Poppler on macOS).

What “direct-to-Gemini” means

• Direct (processing_mode="direct", default): TOXO loads your attachment as bytes (from path/base64/data URL) and sends it straight to Gemini. This avoids local dependencies like Poppler/pdf2image/PyMuPDF.
• Local (processing_mode="local"): TOXO routes documents through the local processing pipeline (optional, heavier). Use this when you explicitly want local extraction/heuristics.

Supported inputs

• Images: bytes, filesystem Path/str, base64 string, data URL (data:image/...;base64,...)
• Documents: filesystem Path/str, base64 string, data URL (data:application/...;base64,...)
• Non-PDF base64: if you pass raw base64 (not a data URL), provide mime_type="...".

Image (bytes / path / base64 / data URL)

import asyncio
from toxo import ToxoLayer

async def main():
    layer = ToxoLayer.load("doc_expert.toxo")
    layer.setup_api_key("YOUR_GEMINI_API_KEY", "gemini-2.5-flash-lite", "gemini")

    resp = await layer.query_multimodal(
        "Extract the key numbers from this screenshot.",
        image_data="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..."
    )
    print(resp)

asyncio.run(main())

PDF (path OR base64/data URL)

import asyncio
from toxo import ToxoLayer

async def main():
    layer = ToxoLayer.load("doc_expert.toxo")
    layer.setup_api_key("YOUR_GEMINI_API_KEY", "gemini-2.5-flash-lite", "gemini")

    # Option A: filesystem path
    resp = await layer.query_multimodal(
        "Summarize this PDF in 5 bullets.",
        document_path="report.pdf",
    )
    print(resp)

    # Option B: base64 (raw or data URL)
    resp2 = await layer.query_multimodal(
        "List the top 10 entities mentioned in this PDF.",
        document_data="data:application/pdf;base64,JVBERi0xLjcKJc..."
    )
    print(resp2)

    # Tip: for non-PDF base64 (without a data URL), pass the mime_type explicitly.
    resp3 = await layer.query_multimodal(
        "Extract the key numbers from this PNG.",
        image_data="iVBORw0KGgoAAAANSUhEUgAA...",  # raw base64 (not a data URL)
        mime_type="image/png",
    )
    print(resp3)

asyncio.run(main())

Testing (developer utilities)

TOXO includes an end-to-end capability runner that reports PASS/FAIL/SKIP across subsystems.

• Fast (no network):

python3 testing/toxo_capability_test.py --layer examples/minimal_test_layer.toxo

• Full (live Gemini + multimodal + evidence tests):

python3 testing/toxo_capability_test.py --layer examples/rich_test_layer.toxo --live --multimodal --evidence

Creating a richer local layer for tests

python3 testing/create_rich_test_layer.py

CLI

TOXO ships a small CLI for working with .toxo files:

toxo --help
toxo version
toxo check
toxo info path/to/layer.toxo
toxo validate path/to/layer.toxo
toxo test path/to/layer.toxo
toxo install

TOXO Python Library Features

Capability map (modules → what you can use)

This section is designed for developers evaluating TOXO in depth. It maps the major modules to:

• What it does
• What is stable/public
• Which optional extra installs are typically required

Core runtime (always installed)

• toxo.ToxoLayer (toxo/core/toxo_layer.py)
  • What: load .toxo layers, configure an LLM provider, run queries, manage memory and feedback.
  • Key APIs: load, save, setup_api_key, query (async), query_sync, query_multimodal, add_feedback, get_info.
• toxo.cli (toxo/cli.py)
  • What: toxo check/info/validate/test/install CLI utilities.
• toxo.integrations (toxo/integrations/*)
  • What: Gemini client + multi-provider abstraction.

Agents (optional, but lightweight)

• toxo.agents (toxo/agents/__init__.py)
  • Public surface: orchestrator framework (AgentOrchestrator, LLMAgent, TaskScheduler, MessageRouter).
  • Note: legacy coordinator/message-bus modules exist but are not exported by default.

Cognitive systems (optional / heavier)

• toxo.cognitive (toxo/cognitive/__init__.py)
  • What: self-improvement, advanced RAG, and advanced feedback learning systems.
  • Typical extras: toxo[rag] for retrieval/vectors; some components may require heavier ML deps.

Document processing / multimodal

• Direct-to-Gemini (default): layer.query_multimodal(..., processing_mode="direct")
  • What: send bytes directly to Gemini (PDF/image/any mime), minimal local deps.
• Local processing pipeline (opt-in): TOXO_ENABLE_LOCAL_PROCESSING_PIPELINE=1
  • What: initialize local processors (layout parsing, advanced doc tooling).
  • Typical extras: toxo[vision] (+ Poppler on macOS if you want local PDF rendering).

RAG / vector store

• toxo.core.vector_store.VectorStore
  • What: vector storage and similarity search for retrieval.
  • Typical extras: toxo[rag] (SQLAlchemy + ChromaDB).

🎨 No-Code Smart Layer Creation

Create domain experts through toxotune.com:

• Upload domain-specific examples
• Automatic smart layer optimization
• Advanced training algorithms
• Download trained .toxo layer file

⚡ Universal LLM Compatibility

The toxo python package works with any LLM provider:

• Google Gemini (Recommended - optimized integration)
• OpenAI GPT (GPT-3.5, GPT-4, GPT-4o)
• Anthropic Claude (Claude-3, Claude-3.5)
• Local Models (Ollama, LM Studio, etc.)
• Custom APIs (Any OpenAI-compatible endpoint)

🔄 Continuous Learning

Smart layers improve automatically:

# Provide feedback to enhance performance
layer.add_feedback(
    question="Investment strategy question",
    response="Generated response...",
    rating=8.5,  # Quality score 0-10
    suggestions=["More risk analysis", "Include market timing"]
)

🤖 Multi-Agent Systems

Orchestrate multiple specialized layers:

# Multiple domain experts working together
research_agent = ToxoLayer.load("research_expert.toxo")
writing_agent = ToxoLayer.load("writing_expert.toxo")

# Collaborative AI workflow
research = await research_agent.query("Research quantum computing")
report = await writing_agent.query(f"Write report: {research}")

🎯 TOXO v2.0 Full Power – Quality Scoring & Query Intelligence

from toxo import ToxoLayer
from toxo.core import classify_query, analyze_response, compute_domain_confidence, should_use_layer, compute_info_density, QUALITY_WEIGHTS

# Classify query type (factual, procedural, comparison, technical, vague)
qtype = classify_query("how to dial in espresso", "coffee")  # -> "procedural"
qtype = classify_query("compare aeropress vs v60", "coffee")  # -> "comparison"

# Should you use the layer for this query? (domain confidence)
use_layer, confidence = should_use_layer("random trivia question", "finance", threshold=0.6)

# Analyze response quality with expert-weighted scoring
scores = analyze_response(response_text, query, domain="linkedin")

# Domain confidence and info density
conf = compute_domain_confidence("espresso ratio", "coffee")
density = compute_info_density(response_text, query, domain="finance")

# Layer automatically uses: response depth, query-type instructions, compression
response = layer.query_sync("Compare A vs B", response_depth="concise")  # Auto-formats comparison

TOXO Python Library API Reference

Core Methods

ToxoLayer.load(path)

Load a trained smart layer from .toxo file.

layer = ToxoLayer.load("path/to/domain_expert.toxo")

layer.setup_api_key(api_key, model, provider)

Connect smart layer to any LLM API with model selection.

# Gemini (default)
layer.setup_api_key("your_gemini_key", "gemini-2.5-flash-lite", "gemini")

# OpenAI GPT
layer.setup_api_key("your_openai_key", "gpt-4", "openai")

# Claude
layer.setup_api_key("your_claude_key", "claude-3.5-sonnet", "claude")

layer.query(question, context=None, response_depth=None, **kwargs)

Enhanced query with smart layer processing.

response = layer.query_sync("Domain-specific question")

# With additional context
response = layer.query_sync(
    "Analyze this data", 
    context={"user_role": "analyst", "priority": "high"}
)

# v2.0: Response depth - concise, balanced, or detailed
response = layer.query_sync("Quick tip?", response_depth="concise")    # 1-3 sentences
response = layer.query_sync("Compare X vs Y", response_depth="balanced")  # Auto-escalates for comparisons
response = layer.query_sync("Full guide please", response_depth="detailed")

layer.query_async(question, context=None)

Asynchronous query for high-performance applications.

response = await layer.query("Your question")      # preferred
response = await layer.query_async("Your question") # alias

layer.query_sync(question, ...)

Synchronous wrapper for query(...).

response = layer.query_sync("Your question")

Information & Analytics

layer.get_info()

Get comprehensive layer information.

info = layer.get_info()
print(f"Domain: {info['domain']}")
print(f"Performance Score: {info['performance_score']}")

layer.get_capabilities()

Discover layer capabilities.

capabilities = layer.get_capabilities()
print(capabilities)

layer.get_performance_metrics()

Monitor smart layer performance.

metrics = layer.get_performance_metrics()
print(f"Response Quality: {metrics['avg_quality_score']}")

Creating Smart Layers

Training Process on ToxoTune Platform

1. 🎯 Domain Selection: Choose your area of expertise
2. 📚 Data Upload: Provide domain-specific examples
3. 🏋️ Smart Layer Training: Advanced algorithms create your layer
4. 📦 Download: Get your trained .toxo file
5. 🚀 Deploy: Use with any LLM via this Python library

Example Training Data

Financial Advisory Layer:

• "Should I diversify my portfolio?" → Expert diversification advice
• "Impact of inflation on investments?" → Inflation-hedging strategies
• "Best retirement planning approach?" → Comprehensive retirement guidance

Legal Expert Layer:

• "Contract risk analysis needed" → Detailed legal risk assessment
• "Compliance requirements review" → Regulatory compliance guidance
• "Intellectual property questions" → IP law expert consultation

Domain Expert Examples

🏦 Financial Expert with Different Models

finance_layer = ToxoLayer.load("financial_advisor.toxo")

# Using Gemini (recommended)
finance_layer.setup_api_key("your_gemini_key", "gemini-2.5-flash-lite", "gemini")
advice = finance_layer.query_sync("Portfolio allocation for retirement")

# Using GPT-4
finance_layer.setup_api_key("your_openai_key", "gpt-4", "openai")
advice = finance_layer.query_sync("Portfolio allocation for retirement")

# Using Claude
finance_layer.setup_api_key("your_claude_key", "claude-3.5-sonnet", "claude")
advice = finance_layer.query_sync("Portfolio allocation for retirement")
# Output: Expert financial planning with risk assessment

⚖️ Legal Expert with Model Selection

legal_layer = ToxoLayer.load("legal_advisor.toxo")

# Choose the best model for legal analysis
legal_layer.setup_api_key("your_api_key", "gpt-4", "openai")
analysis = legal_layer.query_sync("Review this contract for issues")
# Output: Comprehensive legal analysis with risk identification

🔬 Research Assistant with Multiple Models

research_layer = ToxoLayer.load("research_assistant.toxo")

# Use Claude for research (excellent at analysis)
research_layer.setup_api_key("your_claude_key", "claude-3.5-sonnet", "claude")
review = research_layer.query_sync("Latest developments in quantum computing")
# Output: Detailed research summary with current insights

💻 Code Expert with Model Flexibility

code_layer = ToxoLayer.load("python_expert.toxo")

# Use GPT-4 for code analysis (excellent at programming)
code_layer.setup_api_key("your_openai_key", "gpt-4", "openai")
review = code_layer.query_sync("Optimize this function for performance")
# Output: Expert code analysis with optimization recommendations

Advanced Usage Patterns

Context-Aware Processing

# Rich context for enhanced responses
context = {
    "user_profile": {
        "role": "portfolio_manager",
        "experience": "senior"
    },
    "session_data": {
        "previous_topics": ["risk_assessment", "market_analysis"]
    }
}

response = layer.query_sync("Investment recommendation", context=context)

Batch Processing

# Process multiple queries efficiently
queries = [
    "Analyze AAPL performance",
    "Tech sector risk assessment", 
    "Q4 2024 market outlook"
]

results = []
for query in queries:
    result = await layer.query(query)
    results.append(result)

Installation & Requirements

Standard Installation

pip install toxo

Optional extras (recommended)

pip install "toxo[openai]"        # OpenAI provider support
pip install "toxo[claude]"        # Anthropic provider support
pip install "toxo[rag]"           # Vector store + retrieval
pip install "toxo[vision]"        # Optional local document/image tooling
pip install "toxo[auth]"          # JWT + bcrypt
pip install "toxo[distributed]"   # Redis-backed features
pip install "toxo[enterprise]"    # Monitoring/telemetry (optional)
pip install "toxo[full]"          # Everything (largest install)

Installation with Specific LLM Providers

# For OpenAI GPT models
pip install toxo[openai]

# For Claude models
pip install toxo[claude]

# For all providers
pip install toxo[full]

Development Installation

pip install toxo[dev]

System Requirements

• Python: 3.9+ (3.10+ recommended)
• Memory: 4GB RAM minimum
• Internet: Required for LLM API calls
• API Keys: Supported LLM provider account

Supported LLM Providers

• ✅ Google Gemini (Recommended - included by default)
  • gemini-2.5-flash-lite, gemini-1.5-pro, gemini-1.5-flash
• ✅ OpenAI GPT (Install with pip install toxo[openai])
  • gpt-4, gpt-4o, gpt-3.5-turbo
• ✅ Anthropic Claude (Install with pip install toxo[claude])
  • claude-3.5-sonnet, claude-3-opus, claude-3-haiku
• 🔄 Local Models (Coming soon)

Performance Benefits

Cost Comparison

• Traditional Fine-tuning: $10,000-$100,000+ per domain
• TOXO Smart Layers: $5-$500 per domain
• Savings: Up to 1000x cost reduction

Time Comparison

• Traditional Fine-tuning: Days to weeks
• TOXO Smart Layers: Minutes to hours
• Speed: Up to 500x faster deployment

Quality Results

• Performance: 95-98% of fine-tuned model quality
• Consistency: Superior response reliability
• Adaptability: Continuous improvement from feedback

Community & Support

📚 Resources

• Documentation: TOXO docs
• Providers: Live multi-provider guide
• API Reference: See README.md + toxo --help + source modules under toxo/
• Tutorials: See examples/ and testing/

💬 Community

• Discord: discord.gg/toxotune
• GitHub: github.com/toxotune/toxo-python
• Stack Overflow: Tag toxo-python-library

🏢 Enterprise

• Enterprise Support: [e-mail]
• Custom Solutions: Large-scale deployments
• Priority Support: 24/7 technical assistance

Frequently Asked Questions

What is the TOXO Python Library?

The TOXO Python Library is a smart layer platform that enhances any black-box LLM with domain expertise, memory, and continuous learning capabilities without expensive retraining.

How does TOXO differ from fine-tuning?

TOXO creates intelligent layers that attach to existing LLMs, achieving 95-98% of fine-tuned performance with 1000x cost reduction and universal LLM compatibility.

Can I use TOXO with any LLM?

Yes! The toxo python package works with any LLM API including GPT, Gemini, Claude, and local models. Smart layers are completely LLM-agnostic.

What's inside a .toxo file?

.toxo files contain trained smart layer components, memory systems, and configuration - everything needed to transform any LLM into a domain expert.

Is TOXO production-ready?

Absolutely! The TOXO Python Library includes enterprise features like monitoring, scaling, security, and professional support options.

How much training data do I need?

TOXO's smart layer training is extremely efficient - most domains need only 10-100 examples compared to thousands required for traditional approaches.

Getting Started Checklist

• Install: pip install toxo
• Sign Up: Create account at toxotune.com
• Choose Domain: Select your expertise area
• Upload Examples: Provide domain-specific data
• Train Layer: Create your smart layer
• Download: Get your .toxo file
• Test: Load and test with this Python library
• Deploy: Integrate into your application
• Optimize: Provide feedback for improvement

License

The TOXO Python Library is proprietary software. See LICENSE file for details.

---

TOXO Python Library - Revolutionizing AI with Smart Layers 🧠⚡

Transform any LLM into a domain expert with the power of smart layer technology

Ready to experience revolutionary LLM enhancement? Start with pip install toxo and join the smart layer revolution!

---

Keywords: toxo python library, smart layer training, context augmented language models, calm, black-box llm enhancement, llm conversion, domain expert ai, toxo layer, python library, ai augmentation, llm enhancement, no llm retraining, toxo python package, ai layer training, toxo ai, toxo library