Saptiva Agents

A professional multi-agent framework built on AutoGen v0.4+, designed for building production-ready AI agent systems with native Python tools, minimal dependencies, and enterprise-grade reliability.

Table of Contents

• Overview
• Architecture
• Installation
• Quick Start
• Core Concepts
• Creating Custom Tools
• Agent Patterns
• Available Models
• API Reference
• Best Practices
• Migration from v0.2.3
• Contributing
• License
• Links
• Support

Overview

Saptiva Agents is an enterprise-focused framework for building multi-agent AI systems. It provides:

• Native Tool System: Pydantic-based tools with automatic schema generation (no LangChain dependency)
• Minimal Dependencies: 86.7% smaller installation footprint (108 MB vs 754 MB)
• Production Ready: Built on AutoGen v0.4+ with robust error handling and async support
• Type Safe: Full type hints with mypy/pyright compatibility
• Extensible: Easy to create custom agents, tools, and orchestration patterns

Architecture

System Architecture

graph TB
    subgraph "Client Layer"
        User[User Application]
        API[FastAPI REST API]
    end

    subgraph "Framework Layer"
        Framework[SaptivaAgentsFramework]
        Framework --> Parser[Request Parser]
        Framework --> ModelSelector[Model Selector]
        Framework --> AgentFactory[Agent Factory]
    end

    subgraph "Agent Layer"
        Assistant[AssistantAgent]
        UserProxy[UserProxyAgent]
        Custom[Custom Agents]
    end

    subgraph "Tool Layer"
        SaptivaTool[SaptivaTool Base]
        NativeTools[Native Tools]
        CustomTools[Custom Tools]
        SaptivaTool --> NativeTools
        SaptivaTool --> CustomTools
    end

    subgraph "Model Layer"
        ModelClient[SaptivaAIChatCompletionClient]
        SaptivaAPI[Saptiva API]
        OpenAI[OpenAI Compatible APIs]
        ModelClient --> SaptivaAPI
        ModelClient --> OpenAI
    end

    User --> API
    API --> Framework
    Framework --> Assistant
    Framework --> UserProxy
    Framework --> Custom
    Assistant --> NativeTools
    Assistant --> CustomTools
    Assistant --> ModelClient
    UserProxy --> ModelClient
    Custom --> ModelClient

    style Framework fill:#e1f5ff
    style ModelClient fill:#fff4e1
    style SaptivaTool fill:#f0f0f0

Key Components

• SaptivaAgentsFramework handles request parsing, model selection, and agent creation.
• AssistantAgent runs tasks and can call tools; UserProxyAgent enables human-in-the-loop control.
• SaptivaTool is the native tool base and converts to AutoGen FunctionTool.
• Teams like RoundRobinGroupChat and SelectorGroupChat coordinate multi-agent runs with termination conditions.

Execution flow (high level): client → framework → agent(s) → tools/model → response.

Installation

Minimal Installation

pip install saptiva-agents

This installs the core framework with 48 packages (~108 MB).

With Optional Features

# With web browsing capabilities (Playwright)
pip install saptiva-agents[web-surfer]

# With development tools
pip install saptiva-agents[dev]

# Full installation
pip install saptiva-agents[all]

Requirements

• Python 3.10 or higher
• Async runtime support (asyncio)
• Saptiva API key or compatible OpenAI-format API

Quick Start

1. Basic Agent

import asyncio
from saptiva_agents import SAPTIVA_LEGACY
from saptiva_agents.base import SaptivaAIChatCompletionClient
from saptiva_agents.agents import AssistantAgent

async def main():
    # Initialize model client
    model_client = SaptivaAIChatCompletionClient(
        model=SAPTIVA_LEGACY,
        api_key="your-api-key"
    )

    # Create agent
    agent = AssistantAgent(
        name="assistant",
        model_client=model_client,
        system_message="You are a helpful assistant."
    )

    # Run task
    response = await agent.run(task="Explain async programming in Python")
    print(response.messages[-1].content)

    await model_client.close()

asyncio.run(main())

2. Agent with Tools

import asyncio
from saptiva_agents import SAPTIVA_TURBO
from saptiva_agents.base import SaptivaAIChatCompletionClient
from saptiva_agents.agents import AssistantAgent
from saptiva_agents.tools import get_weather, wikipedia_search

async def main():
    model_client = SaptivaAIChatCompletionClient(
        model=SAPTIVA_TURBO,  # Model with tool support
        api_key="your-api-key"
    )

    agent = AssistantAgent(
        name="research_assistant",
        model_client=model_client,
        tools=[get_weather, wikipedia_search],
        system_message="You can search Wikipedia and check weather."
    )

    response = await agent.run(
        task="What's the weather in Tokyo and tell me about the city"
    )
    print(response.messages[-1].content)

    await model_client.close()

asyncio.run(main())

3. Multi-Agent Team

import asyncio
from saptiva_agents import SAPTIVA_OPS
from saptiva_agents.base import SaptivaAIChatCompletionClient
from saptiva_agents.agents import AssistantAgent, UserProxyAgent
from saptiva_agents.teams import RoundRobinGroupChat
from saptiva_agents.conditions import MaxMessageTermination

async def main():
    model_client = SaptivaAIChatCompletionClient(
        model=SAPTIVA_OPS,
        api_key="your-api-key"
    )

    # Create specialized agents
    researcher = AssistantAgent(
        name="researcher",
        model_client=model_client,
        system_message="You research topics thoroughly."
    )

    writer = AssistantAgent(
        name="writer",
        model_client=model_client,
        system_message="You write clear, engaging content."
    )

    user = UserProxyAgent(name="user")

    # Create team
    team = RoundRobinGroupChat(
        participants=[researcher, writer, user],
        termination_condition=MaxMessageTermination(max_messages=10)
    )

    # Run team task
    async for message in team.run_stream(
        task="Research and write about quantum computing"
    ):
        print(f"{message.source}: {message.content}")

    await model_client.close()

asyncio.run(main())

Core Concepts

Agents

Agents are autonomous entities that can:

• Execute tasks using LLMs
• Use tools to interact with external systems
• Collaborate with other agents
• Maintain conversation history

Built-in Agent Types:

from saptiva_agents.agents import (
    AssistantAgent,   # LLM-powered agent with tool support
    UserProxyAgent,   # Human-in-the-loop proxy
)

Model Clients

Model clients interface with LLM APIs:

from saptiva_agents.base import SaptivaAIChatCompletionClient

# Basic configuration
client = SaptivaAIChatCompletionClient(
    model="Saptiva Turbo",
    api_key="your-key",
    temperature=0.7,
    top_p=0.9
)

# With custom base URL (OpenAI-compatible)
client = SaptivaAIChatCompletionClient(
    model="gpt-4",
    api_key="your-key",
    base_url="https://api.openai.com/v1"
)

Teams

Teams orchestrate multi-agent collaboration:

from saptiva_agents.teams import (
    RoundRobinGroupChat,  # Sequential turn-taking
    SelectorGroupChat,     # Dynamic speaker selection
)

# Round-robin coordination
team = RoundRobinGroupChat(
    participants=[agent1, agent2, agent3],
    termination_condition=MaxMessageTermination(max_messages=20)
)

Termination Conditions

Control when agent execution stops:

from saptiva_agents.conditions import (
    MaxMessageTermination,      # Stop after N messages
    TextMentionTermination,     # Stop on specific text
    TimeoutTermination,         # Stop after timeout
)

# Example: Stop when agent says "DONE"
termination = TextMentionTermination("DONE", sources=["assistant"])

Creating Custom Tools

Method 1: Simple Async Function (Recommended)

async def search_database(query: str, limit: int = 10) -> dict:
    """
    Search the database for records matching the query.

    Args:
        query: Search query string
        limit: Maximum number of results to return

    Returns:
        Dictionary containing search results
    """
    # Your implementation
    results = await db.search(query, limit)
    return {"results": results, "count": len(results)}

# Use directly with agents
agent = AssistantAgent(
    name="db_assistant",
    model_client=model_client,
    tools=[search_database]
)

Method 2: Pydantic Tool Class (For Complex Tools)

from saptiva_agents.tools import SaptivaTool
from pydantic import BaseModel, Field

class DocumentAnalysisTool(SaptivaTool[dict]):
    """Advanced document analysis with state."""

    name = "analyze_document"
    description = "Analyzes documents and extracts key information"

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.cache = {}

    async def _arun(self, document_url: str) -> dict:
        """
        Analyze a document from URL.

        Args:
            document_url: URL of document to analyze

        Returns:
            Analysis results including entities, summary, sentiment
        """
        # Check cache
        if document_url in self.cache:
            return self.cache[document_url]

        # Perform analysis
        result = await self._analyze(document_url)

        # Cache result
        self.cache[document_url] = result
        return result

    async def _analyze(self, url: str) -> dict:
        # Your analysis implementation
        return {
            "entities": [...],
            "summary": "...",
            "sentiment": "positive"
        }

# Usage
tool = DocumentAnalysisTool(api_key="your-key")
agent = AssistantAgent(
    name="doc_analyst",
    model_client=model_client,
    tools=[tool]
)

Method 3: Factory Function

from saptiva_agents.tools import create_saptiva_tool

async def my_existing_function(param: str) -> str:
    return f"Processed: {param}"

# Convert to tool with custom metadata
tool = create_saptiva_tool(
    my_existing_function,
    name="custom_processor",
    description="Processes strings with custom logic"
)

Tool Development Best Practices

1. Type Hints Required: All parameters and return values must have type hints
2. Docstrings Required: Describe what the tool does (used by LLM)
3. Async Preferred: Use async functions for I/O operations
4. Error Handling: Return descriptive error messages, don't raise exceptions
5. Idempotency: Tools should be safe to call multiple times

Agent Patterns

Architecture Overview

The framework supports four primary multi-agent patterns, each optimized for different use cases:

1. Research Agent with Tools — a single agent orchestrates multiple tools for information gathering and synthesis.
2. Supervisor–Worker — a supervisor delegates subtasks to specialist agents and merges results.
3. Sequential Pipeline — agents transform data in order (validator → analyzer → formatter).
4. Consensus Building — multiple evaluators vote and a simple aggregator produces a final decision.

Pattern 1: Research Agent with Tools

from saptiva_agents.tools import wikipedia_search, get_weather

async def create_research_agent(model_client):
    """Agent that can research topics using multiple sources."""

    # Define custom research tool
    async def search_arxiv(query: str, max_results: int = 5) -> str:
        """Search arXiv for academic papers."""
        # Implementation
        return "Paper results..."

    agent = AssistantAgent(
        name="researcher",
        model_client=model_client,
        tools=[wikipedia_search, search_arxiv, get_weather],
        system_message="""You are a research assistant. Use your tools to:
        1. Search Wikipedia for general information
        2. Search arXiv for academic papers
        3. Check weather if location-relevant

        Always cite your sources."""
    )

    return agent

Pattern 2: Supervisor-Worker Pattern

async def create_supervisor_team(model_client):
    """Supervisor coordinates multiple specialist workers."""

    # Specialist workers
    data_analyst = AssistantAgent(
        name="data_analyst",
        model_client=model_client,
        system_message="You analyze data and provide insights."
    )

    report_writer = AssistantAgent(
        name="writer",
        model_client=model_client,
        system_message="You write clear, professional reports."
    )

    # Supervisor with workers as tools
    from saptiva_agents.tools import AgentTool

    supervisor = AssistantAgent(
        name="supervisor",
        model_client=model_client,
        tools=[
            AgentTool(data_analyst, return_value_as_last_message=True),
            AgentTool(report_writer, return_value_as_last_message=True)
        ],
        system_message="""You coordinate tasks between specialists:
        - Use data_analyst for data analysis tasks
        - Use report_writer for writing tasks
        - Combine their outputs to complete complex requests"""
    )

    return supervisor

Pattern 3: Sequential Processing Pipeline

async def create_processing_pipeline(model_client):
    """Chain of agents processing data sequentially."""

    agents = [
        AssistantAgent(
            name="validator",
            model_client=model_client,
            system_message="Validate and clean input data. Output JSON."
        ),
        AssistantAgent(
            name="analyzer",
            model_client=model_client,
            system_message="Analyze cleaned data. Output insights."
        ),
        AssistantAgent(
            name="formatter",
            model_client=model_client,
            system_message="Format insights into final report."
        )
    ]

    async def process(data: str) -> str:
        result = data
        for agent in agents:
            response = await agent.run(task=result)
            result = response.messages[-1].content
        return result

    return process

Pattern 4: Consensus Building

async def create_consensus_team(model_client, num_agents: int = 3):
    """Multiple agents vote on decisions."""

    agents = [
        AssistantAgent(
            name=f"evaluator_{i}",
            model_client=model_client,
            system_message=f"You are evaluator {i}. Analyze and vote."
        )
        for i in range(num_agents)
    ]

    async def get_consensus(question: str) -> dict:
        votes = []
        for agent in agents:
            response = await agent.run(task=question)
            votes.append(response.messages[-1].content)

        # Aggregate votes
        return {
            "votes": votes,
            "consensus": most_common(votes)
        }

    return get_consensus

Available Models

Text Models (Basic)

Model	Base	Best For	Use Cases
Saptiva Ops	gpt-oss:20b	Reasoning tasks	Autonomous agents, RAG
Saptiva Guard	llama-guard3:8b	Content moderation	Safety, compliance

Text Models (Tool Calling)

Model	Base	Best For	Use Cases
Saptiva Cortex	qwen3-tk:30b	Complex reasoning	Advanced logic, analysis
Saptiva Turbo	qwen3-it:30b	Tool-heavy workflows	Multi-tool agents, orchestration
Saptiva Legacy	llama3.3:70b	Legacy compatibility	Migration, testing

Multimodal Models

Model	Base	Best For	Use Cases
Saptiva OCR	Nanonets OCR-s	Document processing	OCR, forms, invoices

Model Selection Guide

# For simple Q&A without tools
model = SAPTIVA_OPS

# For agents using tools
model = SAPTIVA_TURBO  # Recommended
model = SAPTIVA_CORTEX  # For complex reasoning

# For document processing
model = SAPTIVA_OCR

# For content safety
model = SAPTIVA_GUARD

Model-to-Agent Pattern Mapping

The following table shows recommended model configurations for different agent patterns and use cases:

Agent Pattern	Recommended Model	Tool Support	Best For	Example Configuration
Basic Assistant	SAPTIVA_OPS	❌ No	Simple Q&A, conversation, text generation	Single agent without tools
Research Agent	SAPTIVA_TURBO	✅ Yes	Multi-tool coordination, information gathering	Agent with Wikipedia, ArXiv, Weather tools
Research Agent (Advanced)	SAPTIVA_CORTEX	✅ Yes	Complex reasoning with tools, academic research	Agent requiring deep analysis with tools
Supervisor-Worker	SAPTIVA_TURBO (Supervisor) SAPTIVA_OPS (Workers)	✅ Supervisor ❌ Workers	Task delegation, hierarchical teams	Supervisor coordinates specialist agents
Sequential Pipeline	SAPTIVA_OPS	❌ No	Data transformation, ETL workflows	Chain of validator → analyzer → formatter
Sequential Pipeline (Complex)	SAPTIVA_CORTEX	✅ Yes	Complex transformations with external data	Pipeline with API calls and validation
Consensus Building	SAPTIVA_OPS	❌ No	Decision making, voting systems	Multiple evaluators voting on decisions
Document Processing	SAPTIVA_OCR	❌ No	OCR, form extraction, invoice processing	Agent processing PDFs, images
Content Moderation	SAPTIVA_GUARD	❌ No	Safety filtering, compliance checks	Agent validating user input
Multi-Agent Team (Round Robin)	SAPTIVA_OPS	❌ No	Collaborative brainstorming, discussion	Team with shared conversation context
Multi-Agent Team (Tool-Using)	SAPTIVA_TURBO	✅ Yes	Complex orchestration, external integrations	Team with shared tools and APIs
RAG Agent	SAPTIVA_OPS	✅ Yes	Retrieval-augmented generation	Agent with vector search tool
Code Generation	SAPTIVA_CORTEX	✅ Yes	Programming tasks, code analysis	Agent with code execution tools
Customer Support	SAPTIVA_TURBO	✅ Yes	Ticket handling, knowledge base queries	Agent with FAQ search and CRM tools

Configuration Examples:

# Research Agent - Recommended: SAPTIVA_TURBO
research_agent = AssistantAgent(
    name="researcher",
    model_client=SaptivaAIChatCompletionClient(model=SAPTIVA_TURBO),
    tools=[wikipedia_search, arxiv_search, get_weather]
)

# Supervisor-Worker - Mixed models
supervisor = AssistantAgent(
    name="supervisor",
    model_client=SaptivaAIChatCompletionClient(model=SAPTIVA_TURBO),  # Needs tool calling
    tools=[AgentTool(worker1), AgentTool(worker2)]
)
worker = AssistantAgent(
    name="worker",
    model_client=SaptivaAIChatCompletionClient(model=SAPTIVA_OPS),  # Simple execution
)

# Document Processing - SAPTIVA_OCR
ocr_agent = AssistantAgent(
    name="ocr_processor",
    model_client=SaptivaAIChatCompletionClient(model=SAPTIVA_OCR),
    system_message="Extract text and structure from documents"
)

# Content Moderation - SAPTIVA_GUARD
guard_agent = AssistantAgent(
    name="content_guard",
    model_client=SaptivaAIChatCompletionClient(model=SAPTIVA_GUARD),
    system_message="Analyze content for safety violations"
)

API Reference

Core Classes

SaptivaAIChatCompletionClient

class SaptivaAIChatCompletionClient:
    def __init__(
        self,
        model: str,
        api_key: str,
        base_url: str = "https://api.saptiva.com/v1",
        temperature: float = 0.7,
        top_p: float = 0.9,
        lang: str = "es"
    )

AssistantAgent

class AssistantAgent:
    def __init__(
        self,
        name: str,
        model_client: ChatCompletionClient,
        tools: List[Tool] = None,
        system_message: str = "",
        description: str = "",
        reflect_on_tool_use: bool = False,
        max_tool_iterations: int = 10
    )

    async def run(self, task: str) -> Response
    async def run_stream(self, task: str) -> AsyncIterator[Message]

SaptivaTool

class SaptivaTool(Generic[T]):
    name: str
    description: str

    @abstractmethod
    async def _arun(self, *args, **kwargs) -> T:
        """Implement your tool logic here."""
        pass

    def to_function_tool(self) -> FunctionTool:
        """Convert to AutoGen FunctionTool."""
        pass

Built-in Tools

from saptiva_agents.tools import (
    # Web & Research
    wikipedia_search,        # Search Wikipedia
    WikipediaSearchTool,     # Class-based with fallback

    # Utility
    get_weather,            # Weather information

    # Saptiva Services
    saptiva_bot_query,          # Query Saptiva bot
    obtener_texto_en_documento, # Extract text from documents
    consultar_curp_get,         # CURP lookup (GET)
    consultar_curp_post,        # CURP lookup (POST)
    consultar_cfdi,             # CFDI validation
    get_verify_sat,             # SAT verification
    upload_csv,                 # CSV upload and analysis
)

Best Practices

1. Resource Management

Always close clients properly:

async def main():
    client = SaptivaAIChatCompletionClient(...)
    try:
        agent = AssistantAgent(...)
        result = await agent.run(task="...")
    finally:
        await client.close()

2. Error Handling

from starlette.exceptions import HTTPException

async def safe_agent_call():
    try:
        response = await agent.run(task="...")
        return response
    except HTTPException as e:
        # Handle API errors
        print(f"API Error: {e.detail}")
    except Exception as e:
        # Handle unexpected errors
        print(f"Unexpected error: {e}")

3. Streaming Responses

Use streaming for better UX:

async def stream_response():
    async for message in agent.run_stream(task="..."):
        print(message.content, end="", flush=True)

4. Tool Design

# Good: Clear, focused tool
async def calculate_tax(amount: float, rate: float) -> float:
    """Calculate tax on an amount."""
    return amount * rate

# Bad: Vague, multi-purpose tool
async def do_math(operation: str, *args) -> Any:
    """Do math."""  # Too generic
    ...

5. System Messages

Be specific about capabilities:

# Good
system_message = """You are a financial analyst. You can:
- Analyze balance sheets
- Calculate financial ratios
- Provide investment recommendations

Always show your calculations."""

# Bad
system_message = "You help with finance."  # Too vague

6. Token Management

# Monitor token usage
client = SaptivaAIChatCompletionClient(
    model=SAPTIVA_TURBO,
    api_key="your-key",
    temperature=0.7,
    top_p=0.9  # Control output diversity
)

# Keep prompts concise
task = "Summarize this in 3 bullet points: [...]"

7. Production Web Research Config

For VM‑hosted SearXNG (primary) and Tavily (fallback/proxy), use conservative retry and rate‑limit settings to avoid upstream throttling:

# Primary: self‑hosted SearXNG
SAPTIVA_SEARCH_PROVIDER=searxng
SAPTIVA_SEARCH_BASE_URL=http://searxng.internal:8080
SAPTIVA_SEARCH_MAX_RETRIES=3
SAPTIVA_SEARCH_MIN_INTERVAL_S=0.25   # ~4 req/s per worker

# Page reads (avoid bursty crawling)
SAPTIVA_READ_MAX_RETRIES=2
SAPTIVA_READ_MIN_INTERVAL_S=0.10     # ~10 req/s per worker

# Optional fallback / proxy: Tavily
SAPTIVA_TAVILY_API_KEY=your-tavily-key
SAPTIVA_TAVILY_BASE_URL=https://tavily-proxy.internal/search

Enterprise preset (robust, auditable):

from saptiva_agents.teams import DeepResearchTeamConfig

enterprise_config = DeepResearchTeamConfig(
    search_provider="searxng",
    search_base_url="http://searxng.internal:8080",
    search_max_retries=3,
    search_min_interval_s=0.25,
    read_extractor="trafilatura",  # pip install saptiva-agents[web-research]
    read_max_retries=2,
    read_min_interval_s=0.10,
    cache_ttl_s=900,
    min_sources=5,
    max_turns=16,
)

Startup preset (fast iteration, lower cost):

startup_config = DeepResearchTeamConfig(
    search_provider="tavily",
    search_api_key=os.getenv("SAPTIVA_TAVILY_API_KEY"),
    search_max_retries=1,
    search_min_interval_s=0.0,
    read_extractor="simple",
    cache_ttl_s=300,
    min_sources=3,
    max_turns=10,
)

8. FAQ: Blocked Domains / JS‑Heavy Sites

Some sites (Crunchbase, Pitchbook, Cloudflare‑protected domains) return HTTP 403 to read_page. DeepResearch v2 will skip these sources and search alternatives. If you must access JS/captcha sites:

• Install Playwright web browsing extra: pip install saptiva-agents[web-surfer]
• Use a WebSurfer‑based agent/team for those URLs, or pre‑fetch content through your own proxy.
• Prefer alternative sources (official docs, blogs, papers) to keep runs reliable.

Migration from v0.2.3

Breaking Changes in v0.2.4

1. LangChain Removed

   # Before (v0.2.3)
   from saptiva_agents.tools.langchain import WikipediaSearch
   tool = WikipediaSearch()
   
   # After (v0.2.4)
   from saptiva_agents.tools import WikipediaSearchTool
   tool = WikipediaSearchTool()
   

2. Dependencies Updated

   # Before
   pip install saptiva-agents  # 754 MB, 113 packages
   
   # After
   pip install saptiva-agents  # 108 MB, 48 packages
   

3. Tool Validation Removed

   # Before: Manual validation required
   from saptiva_agents._utils import validate_langchain_instance
   
   # After: Automatic with type hints (no manual validation)
   

Migration Steps

1. Update installation:

   pip install --upgrade saptiva-agents
   

2. Replace LangChain tools:

   # Replace WikipediaSearch
   from saptiva_agents.tools import WikipediaSearchTool
   tool = WikipediaSearchTool()
   

3. Remove manual tool validation (handled automatically)

4. Test your agents thoroughly

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting PRs.

Development Setup

# Clone repository
git clone https://github.com/saptiva-ai/saptiva-agents.git
cd saptiva-agents

# Install with dev dependencies
pip install -e ".[dev]"

# Run tests
pytest tests/

# Run linter
ruff check .

License

• Code: MIT License. See LICENSE-CODE. Portions derived from Microsoft AutoGen remain under MIT.
• Documentation: Creative Commons Attribution 4.0 International (CC BY 4.0). See LICENSE and docs/ATTRIBUTION.md.

This project is a derivative of Microsoft AutoGen and is not affiliated with or endorsed by Microsoft. See NOTICE.md.

Links

• Documentation
• PyPI Package
• GitHub Repository
• Issue Tracker

Support

For support, please:

1. Check the documentation
2. Search existing issues
3. Create a new issue with detailed information

---

Built with AutoGen v0.4+ | Maintained by Saptiva AI