Chinese Version

Traditional LLM agents suffer from three fundamental problems: latency accumulates as tools execute sequentially, reasoning is invisible to the user until the final answer arrives, and interruption is destructive — there is no clean way to interject mid-response.

ASRI is an intelligent dialogue robot service built on Django 4.1 that addresses all three at the system level. Its Interleave Engine enables three breakthrough capabilities — streaming tool use, concurrent tool execution, and adaptive interruption — all powered by a unified Pipeline Agent with LLM native function_calling.

• 🧠 Interleaved Thinking And Answer — As soon as the LLM outputs a complete <tool_call> during streaming, the tool is triggered immediately — without waiting for the full LLM response to finish. Thinking and tool execution overlap in the same stream, cutting first-token latency from seconds to milliseconds.

• 🔀 Parallel Streaming Tool Use — When the LLM plans multiple tool_calls in a single response, AsyncExecutorProcessor runs them all in parallel. No sequential bottleneck, no idle waiting.

• ⚡ Adaptive Interrupt — The Agent loop dynamically adapts its next step on every cycle. Users can interrupt at any moment; the agent merges or sequences the new request intelligently without losing context.

• Database-Driven Prompts: All system prompts loaded from DB per tenant, fully configurable without code changes
• Multi-LLM Support: OpenAI API, Ollama, and any OpenAI-compatible endpoint. More providers coming soon.
• WebSocket Streaming: Real-time token-level streaming via WebSocket and SSE
• RAG Integration: HTTP RAG and FAQ RAG modes
• Multi-Tenant Isolation: Complete tenant-level configuration, skill, and data isolation with Bearer Token auth
• Session Management: Full session and message management with one-to-many and many-to-one conversation modes
• Extensible Architecture: Custom Skills, Tools, Prompts via Provider/Registry pattern
• Database Support: SQLite (default, zero-config) or MySQL (production)
• Docker Support: One-command deployment with Docker Compose

ASRI includes a speech-to-speech voice agent that extends text chat with real-time voice interaction:

• Heartbeat Interaction: Think while listening — generates lightweight thinking entries during user speech, triggers tools concurrently when parameters stabilize
• Full Pipeline: VAD → ASR → LLM Agent Loop → TTS → Streaming Response
• OpenAI Realtime Compatible: WebSocket interface compatible with OpenAI Realtime API
• Multiple TTS Backends: OpenAI TTS, ElevenLabs, Dashscope, and more

The voice backend runs under voice/ and the voice UI is accessible at /voice in the web interface. See voice/README.md for backend setup.

Source: docs/architecture.drawio — open in draw.io to edit.

ARC (Advantage Regularization Conditioning) is a reinforcement learning algorithm designed for open-ended interactive scenarios. It solves the reward fairness problem in multi-policy RL — when an agent must learn when to think silently, when to answer aloud, and when to call tools, global advantage comparison unfairly penalizes shorter strategies.

ARC trains the model to fairly master all these strategies. Combined with the INTER3 channel-separation architecture, it delivers higher accuracy with lower latency:

Key insight: ARC achieves +9.60 over Think baseline on Tau2 Bench (31.35 → 40.95) while cutting TTFT by 74% (4.91s → 1.27s). The latency–quality tradeoff is redefined.

⚠️ The ARC model is not yet included in this open-source release. Stay tuned!

• Python 3.10+
• Node.js 18+

git clone https://github.com/your-org/asri.git
cd asri
./setup.sh       # One-command: venv + pip + npm + build + migrate + seed
./start.sh       # Start the server

Visit http://127.0.0.1:8000/ to start chatting.

See the Installation Guide for step-by-step instructions, Docker deployment, and production configuration.

LLM Providers are configured through the Admin page at http://127.0.0.1:8000/admin/. Navigate to Models section to add your OpenAI, Ollama, or custom LLM providers. Environment variables are not used for LLM configuration.

# Run all tests
cd backend
pytest apps/tests/ -v

# Run specific tests
pytest apps/tests/test_agent.py -v

# Run frontend E2E tests
cd frontend
npm run test:e2e

asri/
├── backend/                 # Django backend
│   ├── apps/                # Application modules
│   │   ├── agent/           # Agent implementations
│   │   ├── api/             # HTTP & WebSocket APIs
│   │   ├── integrations/    # Provider abstractions
│   │   ├── services/        # Business logic
│   │   └── tenant/          # Multi-tenant support
│   ├── manage.py            # Django management script
│   └── requirements.txt     # Python dependencies
├── frontend/                # React frontend
│   ├── src/                 # Source code
│   ├── package.json         # NPM dependencies
│   └── vite.config.ts       # Vite configuration
├── core/                    # Shared agent loop core
├── config/                  # Django project config
├── docs/                    # Technical documentation
├── voice/                   # Voice Agent module (asri-voice package)
│   ├── asri_voice/          # Voice pipeline core (VAD → ASR → LLM → TTS)
│   ├── configs/             # YAML configs and system prompts
│   ├── tests/               # Tests
│   ├── client/              # Replay client
│   └── pyproject.toml       # Voice package dependencies (uv)
├── pyproject.toml           # Root workspace definition (uv)
├── Dockerfile               # Docker image
├── docker-compose.yml       # Docker Compose
├── setup.sh                 # One-command setup script
└── start.sh                 # Startup script

We welcome contributions! Please read our Contributing Guide for details on our code of conduct and the process for submitting pull requests.

If you discover a security vulnerability, please see SECURITY.md for responsible disclosure procedures.

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.