DEV Community: RagLeap

v0.7.5 — Maintenance Snapshot: 5 Packages, 477 Tests Green

RagLeap — Tue, 29 Sep 2026 06:45:56 +0000

No core changes in this one — but if you maintain a monorepo, you know this is the important release.

v0.7.5 is a snapshot since v0.7.0

If you use only ragleap-core, stay on v0.7.0. This is for monorepo users.

What's bundled:

1. ragleap-observability v0.3.0

AlertManager + first real alert rule — verified with curl /api/v1/rules = ok
Prometheus fix: strategy: Recreate to avoid PVC crash-loop
Loki Deployment + Grafana datasource wiring

2. ragleap-tools v0.2.0


python
from ragleap_tools import search_web
# BYOK - plug your own provider
result = search_web("ragleap observability", provider="tavily")




**

## 3. ragleap-rag
**

ingest(metadata={"source": "docs"}) — now supported
Fix: QdrantBackend cosine score normalization
Fix: WeaviateBackend custom port + named-vector search

## **4. Java Port v0.10.0**

+4 backends: Qdrant, Weaviate (live-verified), Milvus, Pinecone

## **5. Housekeeping**

clone-count badge automation (real traction > stars)
SBOM regenerated for compliance
477 tests passing

Why we care about SBOM + badges? Enterprise adoption needs it.

Repo: github.com/antonyrag/ragleap-core

ragleap-rag-java v0.9.0: Adding Milvus as 5th Vector Backend Without a Live Cluster

RagLeap — Mon, 28 Sep 2026 04:58:38 +0000

We just shipped ragleap-rag-java v0.9.0 to Maven Central.

Maven Central stats for September alone:

736 total downloads
55 unique sources
21 companies

And this release adds our 5th vector backend: Milvus.

We now support: PgVector, FaissBackend, QdrantBackend, WeaviateBackend, and now MilvusBackend.

Why Milvus was tricky

Unlike Qdrant/Weaviate, Milvus self-hosting needs 3 services: etcd, MinIO, milvus-standalone. On my current VPS with existing CPU contention, that's too resource-risky.

So I did what I did for the Python version — be honest about it.

What I actually did

Fetched and read Milvus REST v2 API docs directly — not from memory.
Built MilvusBackend against the real spec.
No UUID indirection needed: Milvus VarChar primary key accepts documentId:chunkIndex directly. Simpler than other backends.
18 new tests via local HTTP stub server — same pattern this codebase uses for testing unavailable providers.

This is NOT live-verified against Zilliz Cloud / self-hosted Milvus, and the README says so. Same honest caveat Python MilvusBackend carries.

How to use it

// pom.xml

io.github.antonyrag
ragleap-rag
0.9.0

// Java
var backend = new MilvusBackend(
"http://localhost:19530", // or Zilliz Cloud URL
"your_collection"
);
var rag = new RagleapRag(backend, embeddingConfig);

What's next

Live verification when we have infra, but the API contract is solid — it's built from docs.

If you build Java RAG, try it and star the repo:
github.com/antonyrag/ragleap-core

Good first issues are labeled — looking for contributors for Weaviate live tests and Milvus Cloud verification.

Release: https://github.com/antonyrag/ragleap-core/releases/tag/ragleap-rag-java-v0.9.0

Prometheus 0 Targets and Loki 0 Logs — 5 Real Fixes from ragleap-core Observability Release

RagLeap — Sun, 27 Sep 2026 04:36:45 +0000

We shipped observability for ragleap-core v0.2.0 (v0.2.1 is docs patch).

Stack: Prometheus + Grafana + Loki + Promtail.

Fixes that actually mattered:

ConfigMap corrupted by missing newline


yaml
# Before: two docs merged
# After: Add \n at EOF


**

## 2. Prometheus kubernetes_sd_configs = 0 targets
**

Fix: Replace custom regex, use canonical *path* + cri stage

- source_labels: [__meta_kubernetes_pod_annotation_kubernetes_io_config_path]
  target_label: __path__
  regex: (.+)


**

## 3. Promtail -> Loki DNS
**

loki:
  client:
    url: http://loki-gateway.ragleap.svc.cluster.local:3100/loki/api/v1/push


## **4. postgres-exporter runAsNonRoot
**

securityContext:
  runAsUser: 65534
  runAsNonRoot: true

## **5. Position file starvation**

— Remove diagnostic job sharing positions.yamlVerification:

* kubectl -n ragleap get pods | grep -E 'prometheus|grafana|loki|promtail'
* curl prometheus:9090/api/v1/targets -> activeTargets > 0
* curl loki:3100/loki/api/v1/labels -> 21+ streams

**Release:** https://github.com/antonyrag/ragleap-core/releases/tag/ragleap-observaility-v0.2.0

Implementing 9 Agentic Patterns Without Losing Control — What I Fixed in v0.7.0

RagLeap — Fri, 25 Sep 2026 15:05:24 +0000

Self-correction, ToT, Supervisor routing and why approval-gated actions + token budgets matter more than the patterns themselves.

When we started building agentic workflows, the problem wasn't adding patterns. Chain-of-Thought, Tree-of-Thought, Reflection — all are 50 lines of code. The problem is what happens after you add them.

v0.7.0 is 9 patterns complete. But this post is not about the patterns. It's about the 4 things that broke while adding them.

1. The Tree-of-Thought empty-reply bug

ToT looks great on paper — branch, evaluate, prune. In practice, LLM returns empty string when token budget is tight and your evaluate node crashes with NoneType.

434 shipped ToT. #435 fixed it. We added token-budget aware pruning and empty-reply guard before scoring. Simple fix, but if you implement ToT without it, prod will fail silently.

2. Actionable agents are dangerous by default

We added Webhook, Slack, Email senders (#438) and an LLM-driven action planner (#441) that can propose a real action.

The key decision: the model can propose, never execute. Every action is gated through the existing HITL approval flow. No direct execution path.

If you let your agent send Slack messages directly, you will spam a channel at 2 AM. We learned this in staging.

3. Security is not a feature, it's the cleanup

This release fixed:

7 stack-trace-exposure alerts + 4 raw-exception leaks in API (#439, #440) — leaking internals to client is common when you add new patterns quickly.

Runtime-created AI Employee roles are now auto-detected as sensitive if name/tags say so (#453) — closing a guardrail bypass.

Docker Compose ports now bind to localhost by default (#459) — previously 0.0.0.0.

Approval replies (YES/NO) now only count from configured owner; WhatsApp/Telegram webhooks fail-closed without signature (#460) — prevents anyone approving your agent's actions.

Optional RAGLEAP_API_KEY global middleware auth (#485), off by default.

None of these are sexy. All of them are required before you give an agent real tools.

4. Cost control > prompt optimization

We added usage ledger + token budget caps, global and per-role, including streaming responses (#455, #456).

Without per-role caps, a single Supervisor -> Sub-agent loop (#437) can burn $3 in one query. We now kill the branch when budget hits, not after.

What shipped in v0.7.0

Patterns: self-correction/reflection (#408), CoT (#433), ToT (#434, #435), supervisor routing (#436), sub-agent spawning (#437) — on top of tool registry, observability, HITL, memory from v0.6.0

477 tests passing

Repo clone-count badge, ∼35 community README translations, improved short-query language detection by @hardik47278 (#452)

Full changelog: https://github.com/antonyrag/ragleap-core/releases/tag/v0.7.0

If you're implementing ToT or Supervisor pattern, don't start with the prompt. Start with: what happens when it returns empty, what happens when it loops, and who can approve its side effects.

That’s the part no one writes about.

RagLeap Core v0.4.0 - I Shipped 13 Commits in a Day to Make AI Employees Production-Ready

RagLeap — Sun, 13 Sep 2026 08:50:55 +0000

I just shipped RagLeap Core v0.4.0 after 13 commits in a single day. 480+ commits total, 12 stars, and now it's a production-ready AI Business OS.

What is RagLeap Core?
Self-hosted, MIT licensed AI Business OS — 46 autonomous AI Employees, Graph RAG (Neo4j), multi-channel, BYOK across 17 LLM providers + Ollama, 8 libs (Python + Java).

GitHub: https://github.com/antonyrag/ragleap-core

🔥 What shipped in v0.4.0 (Sep 12)

1. Silent Failures Are Now Loud - `fix(employees)`

Before: Embedding failures in memory system were failing silently. Your AI employee would just forget things.
Now: We surface them. If embedding fails, you know WHY.


python
# Before: silent pass
# After: explicit error surfacing
raise EmbeddingFailure(reason, context)

2. Production RUNBOOK - Because Sh*t Happens

Added RUNBOOK.md for:

db-downneo4j-crash-loopbackup-failurecert-expiredSelf-hosted means YOU own ops. So I documented how to recover when things break. No more guessing at 2 AM.

3. Graph RAG Goes Cross-Chunk - feat(ragleap-graph)
Implemented cross-chunk relation extraction (#154).
Old: Entities linked only within same chunk
New: Relations extracted ACROSS chunks. If Doc says "API rate limit" in page 1 and "429 error" in page 5, Neo4j now links them.
This is real Graph RAG, not just vector search + buzzword.

4. Java Port - 2 More Modules Done
EmbeddingConfig -> JavaConnectionPool (db.py) -> JavaWhy Java? Regulated industries (HIPAA) need Java stack. We're at 9/8 libs now. Yes, more than planned.

5. ragleap-observability is LIVE on PyPI 📦javascriptpip install ragleap-observabilityWith live-verified status, postgres-exporter fix (runAsUser=65534), and proper publish CI job (#332).
Why v0.4.0 Matters

Most RAG demos die in production because:

Silent failures No ops story No observability v0.4.0 fixes all three. Honest truncation notices for streamed answers, RUNBOOK, PyPI observability.

Philosophy: Guardrailed autonomy for regulated industries. AI employees should be autonomous BUT you should be able to debug them.
Stack

Vector: pgvectorGraph: Neo4j (gracefully degrades if down)LLM: BYOK - 17 providers + OllamaLanguages: Python + JavaLicense: MIT - fully self-hostedWhat's Next?

Product Hunt launch this week50 stars goal (12 -> 50)Multi-hop graph traversal wired into retrievalIf you're building self-hosted AI, give it a star and tell me what breaks. I ship fixes same day - literally 13 commits yesterday.

Try it:bashgit clone https://github.com/antonyrag/ragleap-core
docker-compose up

Why We Put "What This Doesn't Do Yet" Right Next to the Feature List

RagLeap — Tue, 04 Aug 2026 06:23:33 +0000

Every RAG library launch post leads with capability. We're leading with scope, because scope is the thing that actually determines whether a library fits your project — and most launch posts quietly skip it.

The technical case for narrow scope

ragleap-rag does retrieval-augmented generation. It does not do agentic tool-calling, multi-step orchestration, or human-in-the-loop approval gates. That's not a v1.0 limitation we're apologizing for — it's a deliberate boundary, because bolting agent reasoning onto a retrieval library usually means neither part is done well.

If you need that, it's a separate, not-yet-built package (ragleap-agents, ragleap-flows) on the roadmap — not a half-implemented feature living inside this one.

What v0.11.1 actually ships

Retrieval: hybrid dense (pgvector cosine) + sparse (Postgres full-text) fused via Reciprocal Rank Fusion. hybrid=False for dense-only when you want one query instead of two.

Reranking: cross-encoder via ONNX Runtime, CPU-only, ~23MB. No torch, no CUDA — the model most reranking libraries pull in defaults to a 2GB+ install even if you never touch a GPU.

Vector backends: 6 total, merged directly into core rather than kept as a separate package. pgvector and FAISS are live-verified against real services today. Pinecone, Weaviate, Qdrant, and Milvus are code-complete but not yet live-tested — we're not claiming parity until they are.

Reliability: chained fallbacks (not just one), real per-call token/cost numbers pulled from the provider's own response, async twins for every method, connection pooling, Redis-backed distributed query caching for multi-process deployments.

Ingestion: 28 file formats, URLs (via trafilatura for clean extraction), images (OCR + vision captioning), audio and video (ffmpeg extraction + pluggable transcription), concurrent mixed-type batch ingestion with per-item failure isolation.

Testing: 238 automated tests, real CI on every PR, up from 72 at the last major checkpoint.

python
pip install ragleap-rag

from ragleap import RagLeap, ProviderConfig, EmbeddingConfig

rag = RagLeap(
database_url="postgresql://user:pass@localhost/mydb",
embedder=EmbeddingConfig(provider="gemini", api_key="..."),
primary=ProviderConfig(provider="gemini", api_key="..."),
)
rag.init_schema()

result = rag.ingest("handbook.pdf", raw_bytes)
answer = rag.ask("What's our PTO policy?")
What's next

ragleap-graph (knowledge-graph-augmented retrieval via Neo4j) and ragleap-integrations (MCP-native + curated connectors) are next on the roadmap. ragleap-agents and ragleap-flows come after — deliberately sequenced, not rushed in to chase a feature-parity headline against LangChain.

Repo: github.com/antonyrag/ragleap-core PyPI: pypi.org/project/ragleap-rag

Genuinely interested in what breaks when you try it on something real — that's what the issue tracker is for.

The Bottleneck Isn't the Model. It's the Prompt You Didn't Write.

RagLeap — Thu, 16 Jul 2026 09:22:25 +0000

Every few weeks there's a thread about some LLM "failing" at a task. Half the replies are someone else running the same task, getting a solid result, and just not saying what prompt they actually used.

This isn't a defense of any particular model. It's a pattern worth naming: most "the AI got it wrong" reports are actually underspecified-request reports.

The gap that always existed

We've always had this problem with underspecified tickets. "Fix the login bug" without repro steps, expected behavior, or environment details gets you a fix — maybe not the right one. Nobody's surprised when that ticket produces a mismatched result. We just say the ticket needed more detail.

LLMs get a different reaction to the same failure mode. Instead of "the prompt needed more detail," it's "the model isn't good enough yet." Sometimes that's true. Often it's the same underspecified-ticket problem wearing a new interface.

What actually changes the output

Not length. Specificity. Compare:

"Write a function to validate user input"

vs.

"Write a function that validates a signup form:
email (RFC 5322, not just regex-lite), password
(min 12 chars, 1 number, 1 symbol), and username
(alphanumeric + underscore, 3-20 chars). Return a
list of specific error messages, not just true/false.
Python, no external deps beyond stdlib."

Same model. Wildly different output quality. Nothing about the model changed between those two requests — the constraint surface did.

The unglamorous actual skill

This is closer to writing a good spec or a good code review comment than it is to any "prompt engineering" secret technique. Explicit constraints. Explicit definition of done. Explicit scope boundaries (what NOT to do, sometimes matters more than what to do).

Most of us already know how to do this — we do it for Jira tickets, PR descriptions, code review comments. The skill transfers almost directly. It just doesn't feel like it should, because talking to an LLM still feels conversational instead of like writing a spec.

The actual debug step

Before filing a "the model can't do this" bug report against reality: would a new hire, handed the literal text of your prompt and nothing else, have produced something meaningfully better?

If not — that's not a model limitation. That's a spec problem, and it's fixable in the next five minutes, same as tightening a vague ticket.

The Complete RagLeap Guide — Every Feature, Explained Step by Step

RagLeap — Sat, 04 Jul 2026 10:03:20 +0000

How to set up and run an AI business manager that answers customers on WhatsApp, Telegram, Discord, and real phone calls — with its own memory, its own knowledge base, and an executive assistant for the owner.
I'm the founder of RagLeap, and this is the complete technical walkthrough of everything it does — written for anyone evaluating it, setting it up, or curious how a multi-channel RAG + voice AI system is actually structured under the hood.
Most AI chatbot tools do one thing: answer questions on a website widget. RagLeap is built differently — it's a full AI business manager that runs across five channels (Web, WhatsApp, Telegram, Discord, and real Voice calls via Twilio), backed by PostgreSQL + pgvector for embeddings and Neo4j for a knowledge graph layer, with a persistent memory system that survives across sessions and channels instead of resetting every conversation.
This guide covers every part of the platform in the order you'd actually set it up.
Table of Contents

Dashboard — Your Home Screen
RagLeap Manager — Your AI Executive Assistant
AI Employees — A Specialized Team, Not One Bot
Documents — Building Your AI's Knowledge Base (RAG)
Integrations — Connecting Your Existing Tools
n8n Workflows — No-Code Automation
Voice AI — Answering Real Phone Calls
WhatsApp Business Bot Setup
Telegram Bot Setup
Discord Bot Setup
Database — Cloud vs. Self-Hosted
Billing & Analytics — Credits and Costs
Persistent Memory Dashboard
Language Settings — 222+ Languages
AI Settings — Model, Temperature, Your Own API Key
Account — Plans, Team, Billing
Audit History
AI Chat — Testing Before You Deploy
Embedding the Chatbot on Your Website
FAQ

Dashboard — Your Home Screen Every session starts on the Dashboard. It's a status check: is everything working, and what happened while you were away? The top bar shows your current workspace name, document count, total workspace size, and a workspace switcher — relevant if you're managing multiple businesses or clients under one account. On the page:

Getting Started checklist — Upload Documents, Configure AI, Start Chatting, Deploy Chatbot. Dismissible after onboarding.
Quick stats — Documents count, Storage used, Queries Today, Current Workspace.
RAG Quality panel — retrieval benchmark scores: nDCG@k, Hit@k, MRR@k, Recall@k. This is an information-retrieval metric — it measures whether the right source document surfaces in the top-k results for a test query set, not whether the generated answer's wording is correct. Above ~0.9 is considered healthy.

RagLeap Manager — Your AI Executive Assistant This is the feature that differentiates RagLeap from a typical RAG chatbot. Manager AI is a private assistant scoped only to the workspace owner — never exposed to customers — reachable via Web, Telegram, WhatsApp, or a direct phone call. Capabilities:

Read access — every document (public and private), analytics, team permissions, database connections, channel config, credit balance
Write access — configure channels, connect/query databases, generate and export reports (PDF/Excel/CSV), send emails, manage team members, change AI model/settings, deploy automations
Analysis — sales, financial (P&L, cash flow), business strategy, and customer behavior analysis, run against your documents or a live connected database, in natural language

Because it runs on the same persistent memory system as everything else, a conversation started on Telegram carries over to a phone call or the web app — it's one continuous context, not five disconnected sessions per channel.

AI Employees — A Specialized Team, Not One Generic Bot Every workspace is seeded with a set of AI Employee roles by default — each with its own permanent memory scope and area of expertise, rather than routing every query through one generic system prompt. How the learning loop works:

Roles are seeded automatically on workspace creation
Each role's skill context is injected into the active channel handler (voice, WhatsApp, web, Telegram) based on conversational intent
learn_from_conversation() runs across every channel — real conversations write new permanent memory, not just session-scoped context
A weekly Celery beat task reinforces learned patterns across all workspaces every Sunday

Inspect roles and their memory entries at /ai-employees/.

Documents — Building Your AI's Knowledge Base (RAG) This is the retrieval corpus everything else depends on. Upload documents → they're chunked → embedded → indexed → retrieved at query time with citations back to source. Pipeline, in three steps:

Upload — PDF, DOCX, TXT, or a raw URL
Processing — auto-chunked, embedded (Google Gemini embedding model, 3072 dimensions), and indexed
Retrieval — queries in Chat return cited answers pulled from the indexed corpus

Supported formats: PDF, DOC, DOCX, XLSX, XLS, CSV, XSL/XSLT, PPT, PPTX, HTML, JSON, XML, RTF, ODT, ODS, ODP, EML, ZIP, SQL, TXT, MD — up to 50MB/file.
Visibility model: Public documents are retrievable by both customer-facing channels and Manager AI. Private documents are retrievable only by Manager AI — the correct place for financial data, contracts, or anything that shouldn't leak to a customer-facing bot.
Post-indexing, the same nDCG@k / Hit@k / MRR@k / Recall@k benchmark from the Dashboard runs automatically here too.

Integrations — Connecting Your Existing Tools Rather than requiring migration into RagLeap, Integrations connects to systems you're already running, with AI-suggested automations per channel and a developer-level automation layer for custom logic. Same Public/Private visibility model applies to connected databases here as it does to Documents.
n8n Workflows — No-Code Automation Direct integration with n8n — trigger workflows mid-conversation, on any channel:

"Customer requested a callback" → create a CRM lead
"Urgent order query" → post to Slack/Discord
"Appointment confirmed" → send calendar invite / SMS

Setup: connect your n8n instance at /n8n-workflows/, map trigger conditions to specific workflows. Runs identically across voice, WhatsApp, web chat, and Telegram once configured.

Voice AI — Answering Real Phone Calls The most technically involved channel: a Twilio number routes into a pipeline of STT (Whisper or Deepgram) → RAG/AI response → TTS (OpenAI or ElevenLabs), with total round-trip latency in the 2–3 second range in production. Call routing logic:

Owner Mode — call from your registered owner number → routes to Manager AI (full private access)
Customer BPO Mode — any other number → routes to RAG-powered customer support, backed by your documents and live database

Setup:

Add Twilio Account SID, Auth Token, Phone Number → save
Copy the generated webhook URL into Twilio Console → Phone Numbers → Voice URL
Enable "Enable Twilio PSTN" → save
Test: call from your owner number (Manager AI) vs. any other number (Customer BPO)

Language auto-detection is real-time — a caller saying "switch to Tamil" or "speak in Hindi" mid-call triggers an instant language switch, no reconnection needed. TTS choice: OpenAI TTS (default, uses your existing key) or ElevenLabs (more natural, 200+ languages, needs its own key).
A Live Voice Test Console lets you test the full pipeline in-browser before wiring up a real number, with live Response/Audio/Total/Status metrics (browser testing adds ~2s of buffering vs. a real call).

WhatsApp Business Bot Setup Two supported providers: ProviderBest forApprox. costTwilioReliability, documentation~$0.005–0.08/msgGupshupCost, Indian company, fast +91 approval~$0.001–0.05/msg Critical constraint: a phone number cannot run personal WhatsApp and WhatsApp Business API simultaneously. Once registered as a bot number, it's locked out of normal WhatsApp use. Use a dedicated SIM or VoIP/landline number that can receive an OTP. Twilio: get a sandbox/production WhatsApp number → copy Account SID + Auth Token into RagLeap → test connection → set webhook to https://ragleap.com/api/whatsapp/webhook/ in Twilio Console. Gupshup: create a WhatsApp app → copy API Key + App Name into RagLeap → test connection → set Callback URL to https://ragleap.com/api/whatsapp/gupshup-webhook/.
Telegram Bot Setup Fastest setup path, typically under two minutes:

Message @botfather on Telegram, send /newbot
Copy the returned Bot Token
Paste into RagLeap's Telegram Bot page, enable, save
Register the webhook URL with Telegram's API (single browser GET or curl -X POST)
Test by messaging your bot directly

Most common failure mode: "Message Content Intent" not enabled, or a trailing space in the copied token.

Discord Bot Setup

Create an application in the Discord Developer Portal, add a Bot user, copy the Bot Token
Enable "Message Content Intent" under Privileged Gateway Intents
Paste Bot Token + Application ID into RagLeap, enable, save
Generate an OAuth2 invite URL (bot scope + Send Messages / Read Message History / View Channels), invite to your server
Mention the bot or message in an accessible channel

Note: these bots often show "offline" in the member list since they're webhook-based rather than maintaining a persistent gateway connection — this is expected and doesn't affect responsiveness.

Database — Cloud vs. Self-Hosted FeatureCloudSelf-HostedSetup timeInstant~10 min (curl installer)Data locationRagLeap infraYour infra onlyNeo4j knowledge graphIncludedIncludedOffline capableNoYesBest forStartups, teamsRegulated industries (health, finance, legal) Self-hosted is a one-time license fee rather than a subscription — relevant if data residency/compliance is a hard requirement.
Billing & Analytics — Credits, API Costs, and Usage Tracks AI credits, per-provider API key configuration, and cost breakdown. Credits: 1 credit = 1 chat query on RagLeap's System AI; 0.1 credit = 1 embedding chunk. Bring your own API key and no credits are consumed — costs bill directly to your provider account instead. Per-provider cost breakdown (Google Gemini, OpenAI, Anthropic Claude) shows API calls, tokens consumed, and estimated cost, with 7/30/90-day trend views.
Persistent Memory Dashboard The core differentiator vs. session-based chat tools: memory here is genuinely persistent, retrieved by semantic similarity rather than keyword match. Pipeline:

Store — fact/preference saved as a memory entry (manual or automatic)
Embed — vectorized for semantic search
Retrieve — relevant memories surfaced by meaning at query time
Inject — retrieved memories added to the AI's context window

Two scopes: User-level (portable across all your workspaces) and Workspace-level (shared across your team, e.g. escalation rules, pricing policy). Auto-compression kicks in when an entry exceeds a configurable token threshold. Full CRUD from this page, plus JSONL export and bulk purge.

Language Settings — 222+ Languages, Auto-Detected Documents are scanned for language distribution (token-weighted). Chat Language Preference supports 222+ built-in languages plus any custom ISO code (up to 2 total). Auto-detect query language, when enabled, matches the customer's actual input language; disabled, it locks to your preferred language regardless of input. This config is genuinely global — applies identically across Web, WhatsApp, Telegram, Discord, and Voice.
AI Settings — Model, Temperature, and Bring Your Own API Key Model choice: Google Gemini (default, fast), OpenAI GPT (complex analysis), Anthropic Claude (detailed reasoning). BYOK isn't limited to the three named providers — also supports OpenRouter, Deepseek, Mistral, and a fully Custom API mode for any OpenAI-compatible endpoint: self-hosted models, Ollama, vLLM, or any third-party inference API reachable by URL. Tuning: Temperature (0.0–1.0; 0.2–0.4 recommended for factual RAG), Top-K Results (chunks reviewed pre-answer; 3–8 typical). A Fallback Key Pool supports multiple keys with automatic failover on rate limits.
Account — Plans, Team, and Billing PlanPriceWorkspacesKey featuresStarter$29/mo1Web + AI ManagerPro$99/mo2+ WhatsApp + TelegramBusiness$199/mo3+ Voice, Team members, no brandingEnterprise$499/mo5+ SLA, dedicated support, custom integrations Also free on your own server — single workspace, web embed, AI Manager with RagLeap branding, no subscription. Team Members (Business/Enterprise) support per-member permission control and group-based bulk permissions.
Audit History Every config/settings change is logged: timestamp, workspace, action type, description, and actor. Filterable by workspace, action type, time range. Necessary once more than one person has admin access.
AI Chat — Testing Before You Deploy Exactly what a customer sees — cited answers, suggested follow-ups generated from your document set. Follows whatever Language Settings config is active, no separate configuration needed. Team Chat, separately, is a plain internal message board with no AI involvement.
Embedding the Chatbot on Your Website Generates embed code in three modes: Widget Bubble (floating button, customizable position/shape/color/size), Fixed Side Panel (pinned left/right), and Full Page / Inline iframe. Branding shown on free/trial tiers, removable on paid plans.
FAQ Setup time? Under 15 minutes for a working AI — documents, one channel, test in AI Chat, go live. Voice/Memory/n8n layer on afterward. Does it replace human support entirely? No — it handles the high-volume, predictable question set (pricing, hours, order status) across every channel in 222+ languages. Judgment-based or emotionally charged conversations still route to a human. Can I run my own model? Yes — any OpenAI-compatible endpoint via Custom API, including self-hosted. Data privacy? Private documents/databases are visible only to Manager AI, never customer-facing bots. Self-hosted keeps everything on your own infrastructure.

Originally published on the RagLeap blog, with product screenshots for each section. Try it at ragleap.com.

How I Built a Production RAG System with Django and Neo4j — Complete Guide

RagLeap — Sat, 20 Jun 2026 07:39:43 +0000

Most RAG tutorials show you how to build a demo. This is not that.

This is how we built a production RAG system that handles real business queries — connecting to live databases, answering customer questions from actual documents, and running 24/7 across WhatsApp, voice calls, and web chat simultaneously.

Here is everything we learned building RagLeap — a self-hosted AI business platform — from scratch.

Why We Chose Django Over FastAPI

Everyone building AI systems defaults to FastAPI. We chose Django. Here is why.

When you are building a product — not a microservice — Django's batteries-included philosophy saves months:

Authentication and multi-tenancy out of the box
ORM that handles complex queries without raw SQL
Admin panel for internal tooling
Mature migration system
Signals for event-driven architecture

We built a custom TenantMiddleware that resolves the workspace from every request context. Every database query, every RAG retrieval, every AI response is automatically scoped to the correct workspace without the developer thinking about it.

pythonclass TenantMiddleware:
def init(self, get_response):
self.get_response = get_response

def __call__(self, request):
    workspace_id = self.resolve_workspace(request)
    request.workspace = Workspace.objects.get(id=workspace_id)
    response = self.get_response(request)
    return response

def resolve_workspace(self, request):
    # Resolve from subdomain, token, or session
    if hasattr(request, 'auth'):
        return request.auth.workspace_id
    return request.session.get('workspace_id')

Why Neo4j Instead of a Vector Database

This is the question we get asked most.

Standard RAG works like this:

Chunk documents
Embed chunks
Store in vector DB
Retrieve by similarity

It works fine for simple Q&A. It breaks down for complex business queries.

Example: "Which customers complained about delivery last month and what products did they order?"

A vector search returns chunks mentioning "complaints" and "delivery." But it cannot traverse the relationship between a complaint, the customer who made it, and the orders associated with that customer.

That is a graph traversal problem — exactly what Neo4j solves.

In RagLeap, we build a knowledge graph from uploaded documents:

pythonfrom neo4j import GraphDatabase

class KnowledgeGraphBuilder:
def init(self, uri, user, password):
self.driver = GraphDatabase.driver(uri, auth=(user, password))

def create_entity(self, entity_type, properties, workspace_id):
    with self.driver.session() as session:
        session.run(
            f"""
            MERGE (e:{entity_type} {{id: $id, workspace_id: $workspace_id}})
            SET e += $properties
            RETURN e
            """,
            id=properties.get('id'),
            workspace_id=workspace_id,
            properties=properties
        )

def create_relationship(self, from_id, to_id, relationship_type, workspace_id):
    with self.driver.session() as session:
        session.run(
            """
            MATCH (a {id: $from_id, workspace_id: $workspace_id})
            MATCH (b {id: $to_id, workspace_id: $workspace_id})
            MERGE (a)-[r:RELATES_TO {type: $rel_type}]->(b)
            RETURN r
            """,
            from_id=from_id,
            to_id=to_id,
            workspace_id=workspace_id,
            rel_type=relationship_type
        )

Entities (customers, products, orders, policies) become nodes. Relationships become edges. When a query comes in, we combine vector similarity search with graph traversal.

The result: Answers that make sense for business queries, not just keyword matches.

The Hybrid Retrieval Pipeline

Here is our actual retrieval pipeline that combines vector search with graph traversal:

pythonclass HybridRetriever:
def init(self, vector_store, graph_db, workspace_id):
self.vector_store = vector_store
self.graph_db = graph_db
self.workspace_id = workspace_id

def retrieve(self, query, top_k=5):
    # Step 1: Vector similarity search
    vector_results = self.vector_store.similarity_search(
        query,
        k=top_k,
        filter={"workspace_id": self.workspace_id}
    )

    # Step 2: Extract entities from query
    entities = self.extract_entities(query)

    # Step 3: Graph traversal from extracted entities
    graph_results = []
    for entity in entities:
        related = self.graph_db.traverse(
            entity,
            max_depth=2,
            workspace_id=self.workspace_id
        )
        graph_results.extend(related)

    # Step 4: Merge and deduplicate results
    combined = self.merge_results(vector_results, graph_results)

    return combined

def extract_entities(self, query):
    # Simple NER — in production we use spaCy or LLM-based extraction
    # Returns list of entity IDs found in query
    pass

def merge_results(self, vector_results, graph_results):
    # Score and deduplicate
    seen = set()
    merged = []
    for result in vector_results + graph_results:
        if result.id not in seen:
            seen.add(result.id)
            merged.append(result)
    return merged[:10]

Celery for Async — The Backbone of Everything

Almost everything in RagLeap that is not a synchronous API response goes through Celery:

Document ingestion and knowledge graph building
Email monitoring and reply drafting
Voice call management
Lead follow-up automation
WhatsApp message processing

We separate Celery beat (scheduler) from Celery workers (executors). Both run as separate Supervisor processes.

python# tasks.py
from celery import shared_task
from .knowledge_graph import KnowledgeGraphBuilder
from .document_processor import DocumentProcessor

@shared_task(bind=True, max_retries=3)
def process_document(self, document_id, workspace_id):
try:
processor = DocumentProcessor()
doc = processor.load(document_id)

    # Extract chunks
    chunks = processor.chunk(doc, chunk_size=512, overlap=50)

    # Embed and store in vector DB
    processor.embed_and_store(chunks, workspace_id)

    # Build knowledge graph
    builder = KnowledgeGraphBuilder()
    entities = processor.extract_entities(doc)
    builder.build_graph(entities, workspace_id)

    return {"status": "success", "chunks": len(chunks)}

except Exception as exc:
    raise self.retry(exc=exc, countdown=60)

Supervisor configuration for separate worker processes:

ini# /etc/supervisor/conf.d/celery.conf
[program:celery_worker]
command=/path/to/venv/bin/celery -A myproject worker --loglevel=info --concurrency=2
directory=/path/to/project
environment=PATH="/usr/bin:/usr/local/bin"
autostart=true
autorestart=true

[program:celery_beat]
command=/path/to/venv/bin/celery -A myproject beat --loglevel=info
directory=/path/to/project
autostart=true
autorestart=true

Multi-Channel Architecture

One AI brain serving WhatsApp, Telegram, Voice calls, Email and web chat simultaneously.

The key insight: normalize everything into the same internal format before it hits the AI.

pythonclass MessageNormalizer:
def normalize(self, raw_message, channel):
return {
"content": self.extract_content(raw_message, channel),
"sender_id": self.extract_sender(raw_message, channel),
"channel": channel,
"timestamp": self.extract_timestamp(raw_message, channel),
"metadata": self.extract_metadata(raw_message, channel)
}

def extract_content(self, message, channel):
    extractors = {
        "whatsapp": lambda m: m.get("body", ""),
        "telegram": lambda m: m.get("text", ""),
        "voice": lambda m: m.get("transcript", ""),
        "email": lambda m: m.get("text_body", ""),
        "web": lambda m: m.get("message", "")
    }
    return extractors[channel](message)

Channel-specific formatting happens on the way out:

pythonclass ResponseFormatter:
def format(self, ai_response, channel):
formatters = {
"whatsapp": self.format_whatsapp,
"voice": self.format_voice,
"email": self.format_email,
"web": self.format_html
}
return formatterschannel

def format_voice(self, response):
    # Remove markdown, make it conversational
    clean = response.replace("**", "").replace("#", "")
    return clean

def format_whatsapp(self, response):
    # WhatsApp supports basic markdown
    return response

Running Everything on a $20/Month VPS

The entire stack — Django, PostgreSQL, Neo4j, Redis, Celery, Nginx, Gunicorn — runs on a 4GB RAM VPS.

Key optimizations:

bash# PostgreSQL — /etc/postgresql/14/main/postgresql.conf
shared_buffers = 512MB
effective_cache_size = 1GB
work_mem = 16MB

Neo4j — /etc/neo4j/neo4j.conf

server.memory.heap.initial_size=256m
server.memory.heap.max_size=512m
server.memory.pagecache.size=256m

Gunicorn — 2-3 workers maximum

gunicorn myproject.wsgi:application \
--workers 2 \
--worker-class gthread \
--threads 4 \
--bind 0.0.0.0:8000

Redis memory limit:

bash# /etc/redis/redis.conf
maxmemory 256mb
maxmemory-policy allkeys-lru

Result: Full AI platform running on 4GB RAM with stable performance under production load.

Database AI — Connecting to Live Data

One of the hardest and most powerful features: letting AI query the user's actual database in natural language.

The challenge: you cannot just give an LLM a database connection and ask it to write SQL. That is a security nightmare.

Our approach:

pythonclass DatabaseAI:
def init(self, connection_string, workspace_id):
self.engine = create_engine(connection_string)
self.workspace_id = workspace_id
self.schema = self.introspect_schema()

def introspect_schema(self):
    inspector = inspect(self.engine)
    schema = {}
    for table_name in inspector.get_table_names():
        columns = inspector.get_columns(table_name)
        schema[table_name] = {
            col['name']: str(col['type'])
            for col in columns
        }
    return schema

def natural_language_query(self, question):
    # Generate safe parameterized query from schema + question
    query_template = self.llm.generate_query(
        question=question,
        schema=self.schema,
        instruction="Generate a safe READ-ONLY SELECT query. No INSERT, UPDATE, DELETE or DROP."
    )

    # Validate query is read-only
    if self.is_safe_query(query_template):
        result = self.execute_safe(query_template)
        return self.format_result(result)
    else:
        return "I can only read data, not modify it."

def is_safe_query(self, query):
    forbidden = ['INSERT', 'UPDATE', 'DELETE', 'DROP', 'TRUNCATE', 'ALTER']
    query_upper = query.upper()
    return not any(word in query_upper for word in forbidden)

This lets a business owner message their AI: "How many orders came from Chennai this week?" — and get a real answer from their actual database.

Memory System

RagLeap maintains persistent memory across conversations using a summarization approach:

pythonclass ConversationMemory:
def init(self, workspace_id, customer_id):
self.workspace_id = workspace_id
self.customer_id = customer_id

def get_relevant_context(self, current_query):
    # Get recent messages
    recent = ConversationHistory.objects.filter(
        workspace_id=self.workspace_id,
        customer_id=self.customer_id
    ).order_by('-created_at')[:10]

    # Get relevant historical summaries from graph
    historical = self.graph_db.get_customer_context(
        customer_id=self.customer_id,
        query=current_query,
        workspace_id=self.workspace_id
    )

    return {
        "recent": [msg.to_dict() for msg in recent],
        "historical": historical
    }

def summarize_and_store(self, conversation_chunk):
    # Periodically compress old conversations
    summary = self.llm.summarize(conversation_chunk)
    self.graph_db.store_conversation_summary(
        customer_id=self.customer_id,
        summary=summary,
        workspace_id=self.workspace_id
    )

What We Would Do Differently

Separate voice processing earlier.
Voice has completely different latency requirements from text. Running it in the same Celery worker pool as document ingestion caused priority issues we had to solve later.
Observability from day one.
Adding proper logging, metrics, and tracing after the fact is painful. Build it in from the beginning.
Schema design for multi-tenancy from migration 1.
Adding workspace isolation to an existing schema costs weeks of refactoring.

Try RagLeap

If you are building AI systems for businesses or looking for a self-hosted AI platform that actually connects to your data, RagLeap has a free self-hosted tier — single workspace, web embed chatbot, and AI Manager included.

GitHub open source launch coming soon — follow along at ragleap.com.

How We Built a True Agentic AI Loop in Django (ReAct Pattern)

RagLeap — Sat, 23 May 2026 19:03:47 +0000

Everyone's building "AI agents." Very few are implementing the actual ReAct pattern correctly.

Here's the core loop we use in RagLeap — and why each step matters:

# RagLeap ReAct Loop (simplified)
plan = agent.think(task, memory)       # REASON: build multi-step plan
result = agent.act(plan, workspace)    # ACT: execute real tool calls
ok = agent.verify(result, plan)        # OBSERVE: did it actually work?

if not ok:
    healed = agent.heal(result)        # HEAL: analyse what broke
    if not healed.success:
        retry_plan = agent.think(      # RE-REASON: new plan with error context
            {**task, 'error': result.message}
        )
        agent.act(retry_plan, workspace)  # RE-ACT: try again differently

The key insight: the re-plan step injects the previous error as context. The agent doesn't just retry — it reasons about WHY it failed and builds a different plan.

What most implementations get wrong:

No verification step — they assume the action succeeded
Retry = same plan again (useless)
No memory between attempts

Our stack:

Django + Celery for async agent tasks
Neo4j for knowledge graph / memory
194 registered tool functions (email, CRM, database, voice)
3-layer observability: AgentTrace DB + Guardrails + Live Dashboard

The hardest part wasn't the LLM calls — it was the adaptation loop and making sure tool calls actually executed (not just "said" they did).

Full architecture writeup: ragleap.com/blog/true-agentic-ai/
Platform: ragleap.com/agentic-ai-platform/

What's the trickiest part of your agent implementation?

Why We Chose Self-Hosted AI Over Cloud for Business Data Posted by the RagLeap team — building RagLeap, a private-server AI business platform

RagLeap — Mon, 04 May 2026 03:34:55 +0000

When we started building RagLeap, the easiest path was obvious: spin up an API, connect to OpenAI, store everything in a managed cloud database, and ship fast.
We didn't do that.
Here's why — and what we learned after talking to hundreds of businesses about where their data actually lives.

The Problem Nobody Talks About
Most AI business tools work like this:

You upload your documents, customer data, order history
It goes to their cloud servers
Their AI processes it
You get answers

It works. But ask yourself: where is your data right now?
For most SaaS AI tools, the honest answer is: on someone else's infrastructure, in a jurisdiction you didn't choose, processed by models you don't control, retained for periods you didn't agree to.
For a solo developer or a small startup, this is fine. For a law firm, a hospital, a financial institution, or any business handling customer PII — it's a compliance nightmare waiting to happen.

What Our Users Actually Told Us
Before building RagLeap, we spoke to businesses across India, the Middle East, and Africa. Three things came up repeatedly:
"We can't send customer data outside our country."
Data residency laws are real and growing. PDPA in Thailand, PDPB in India, GDPR in Europe. A cloud AI tool hosted in US-East doesn't care about your local compliance requirements.
"Our database has 10 years of business history. We're not uploading that anywhere."
This was almost universal among established businesses. Their operational data — sales records, customer interactions, inventory, communications — sits in a PostgreSQL or MySQL database on their own server. They want AI to query it. They don't want to export it.
"We tried [Cloud AI Tool X]. Our customers' WhatsApp messages were being processed in the US."
For businesses in regulated industries, this ended the conversation immediately.

The Self-Hosted Advantage — Beyond Just Privacy
We expected privacy to be the main argument for self-hosting. It is. But we found three other advantages that surprised us:

Cost at Scale Cloud AI tools charge per message, per document, per user. A business handling 10,000 customer interactions per month on a cloud AI platform can pay $500-2,000/month just for usage fees — before the platform subscription. On a self-hosted RagLeap instance, you bring your own API key. You pay OpenAI or Gemini directly, at API rates. For high-volume businesses, this is 60-80% cheaper.
Full Customisation Without Waiting for a Feature Request When your AI is running on your server, you control everything. Custom voice cloning, custom knowledge graph structure, custom RAG retrieval logic, custom webhook integrations. You don't wait for the SaaS vendor to add a feature you need.
Your Data Becomes Your Moat When you connect your 10-year database to a self-hosted AI, that institutional knowledge stays with you. It doesn't train their model. It doesn't improve their product. It doesn't get retained in their servers after you cancel. It's yours — and it makes your AI smarter than any generic cloud tool.

What Self-Hosted Actually Looks Like in Practice
A common misconception is that self-hosted AI requires a dedicated ML team. It doesn't anymore.
RagLeap runs on a standard Ubuntu VPS with 4GB RAM. Installation is a single script. You connect your database, upload your documents, configure your WhatsApp or Telegram channel, and your AI is live — talking to customers in 222+ languages, querying your real data in real-time.
The stack:

Django for the backend API
Neo4j for the knowledge graph (this is the RAG layer)
PostgreSQL for operational data
Celery for async task processing
Nginx + Gunicorn for serving

All of it runs on your VPS. Your data never leaves your server unless you explicitly send it to the AI provider API of your choice — and even that can be replaced with a local model if needed.

When Cloud AI Makes Sense
We're not anti-cloud. Cloud AI tools are excellent for:

Prototyping and MVPs — get something working fast
Individuals and tiny teams — the compliance overhead of self-hosting isn't worth it
Non-sensitive use cases — public-facing chatbots, general Q&A, content generation

If you're a solo developer building a personal project, use whatever is fastest. Self-hosting adds operational responsibility.
But if you're building a product for businesses — especially in regulated industries — or if you're a business with sensitive operational data, the question isn't "should we self-host?" It's "why haven't we already?"

The Practical Checklist
Before choosing between cloud AI and self-hosted, ask:

Does our data contain customer PII?
Are we in a regulated industry (finance, health, legal)?
Do we operate in a country with data residency requirements?
Is our core business data in an existing database we can't export?
Do we process more than 5,000 AI interactions per month?
Do we need customisation beyond what the SaaS tool offers?

If you checked 2 or more boxes — self-hosted AI is worth serious consideration.

Where We Landed
RagLeap is our answer to this problem. It's a self-hosted AI platform that works as your AI Engineer, Customer Support agent, Personal Secretary, and Business Manager — all running on your own server.
It connects to your existing database. It handles WhatsApp, Telegram, Discord, Email, and Voice. It speaks 222+ languages. It runs on a $20/month VPS.
And your data stays exactly where it should — with you.

If you're building AI for businesses that care about data sovereignty, we'd love to hear how you're approaching it. Drop a comment below.
→ ragleap.com — Free self-hosted tier available

Why We Chose Self-Hosted AI Over Cloud for Business Data

RagLeap — Sun, 03 May 2026 09:05:04 +0000

Posted by the RagLeap team — building RagLeap, a private-server AI business platform