DEV Community: RagLeap

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

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

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.

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:

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

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

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

I Made My AI Manager Work Across Telegram, WhatsApp, Web, and Phone Call — With Shared Memory

RagLeap — Sat, 11 Apr 2026 13:49:58 +0000

The hardest part of building RagLeap wasn't the RAG pipeline or the voice integration. It was making the owner's AI Manager feel like ONE continuous brain across four completely different channels.
Here's how I solved it.
The problem
An owner starts a conversation on Telegram: "Connect my PostgreSQL database."
Then the next day they call the Twilio number and say: "What automations did you suggest for my database?"
The voice call should remember the Telegram conversation. They're the same person. One memory.
The solution: ManagerConversation
pythonclass ManagerConversation(models.Model):
workspace = models.OneToOneField(Workspace, ...)
user = models.ForeignKey(User, ...)
# Persistent memory across ALL platforms

class ManagerMemory:
def add_action(self, action, platform, result, params):
# Stores what was done and on which platform

def add_knowledge(self, fact, source, confidence, tags):
    # Stores facts learned about the business

def search_actions(self, action_type=None, limit=20):
    # Retrieve relevant past actions for context

Every action the Manager takes — configuring WhatsApp, connecting a database, sending an email — gets stored with platform context. The next conversation starts with this memory loaded.
Platform routing
python# Telegram handler
@csrf_exempt
def telegram_personal_bot_webhook(request):
message = extract_telegram_message(request)
response = process_manager_message(
workspace=workspace,
message=message,
platform='telegram',
memory=load_manager_memory(workspace)
)
send_telegram_reply(response)

Voice handler

def owner_voice_inbound(request):
speech = request.POST.get('SpeechResult')
response = process_manager_message(
workspace=workspace,
message=speech,
platform='voice',
memory=load_manager_memory(workspace) # Same memory!
)
return twiml_say(response)
Same process_manager_message. Same memory. Different input/output format.
The system prompt
The Manager AI has a ~7,500 token system prompt that includes:

Current workspace status (documents, channels, credits)
Recent actions from memory
Known facts about the business
Full list of 50+ executable actions

This makes every conversation context-aware without any manual session management.
What this enables
Owner on Telegram: "Set up order status checker on WhatsApp"
→ Manager connects DB, generates SQL, deploys to WhatsApp
Next day, owner calls:
→ "Did my WhatsApp automation get deployed?"
→ Manager: "Yes, I deployed order status checker to WhatsApp yesterday at 2:34 PM. 12 customers have used it."
One brain. Four channels.
ragleap.com

How I Built a Multilingual AI Call Center on a 4GB VPS Using Django, Neo4j, and Twilio

RagLeap — Sat, 11 Apr 2026 13:45:32 +0000

I spent 18 months building RagLeap. Here's the full technical breakdown of how I got a production RAG system with voice, WhatsApp, and Telegram running on a $8/month VPS.
The stack
Backend: Django 4.2 + DRF
Vector DB: pgvector (PostgreSQL)
Graph DB: Neo4j (included on all plans, even free)
Queue: Celery + Redis
Voice: Twilio + ElevenLabs TTS
Messaging: Twilio WhatsApp, Telegram Bot API, Discord
AI: Any provider (OpenAI, Gemini, Anthropic, Mistral, private)
Server: 4GB RAM VPS (Ubuntu 24)
The RAG architecture
Standard vector search gets you ~78% retrieval accuracy. That's not good enough for business-critical answers.
I combined pgvector with Neo4j knowledge graphs for hybrid retrieval:
python# Hybrid retrieval: vector (75%) + graph (25%)
result = hybrid_retrieval.search(
query=user_question,
workspace_id=workspace_id,
vector_weight=0.75,
graph_weight=0.25
)
The graph stores entity relationships extracted from documents. When a customer asks "What's included in the Pro plan?", the graph knows that Pro → includes → Feature X → requires → Setup Y. Vector search alone misses these hops.
Result: 94.3% retrieval accuracy.
The multilingual pipeline
No hardcoded translations. Every response is generated by the LLM in the target language:
pythonrag_result = orchestrator.execute_rag(
query=user_message,
language=detected_language, # auto-detected from message
response_language=workspace_language, # forced by workspace settings
custom_api_key=owner_api_key, # owner's own key
)
The workspace owner sets their language. All customer responses come in that language regardless of what language the customer writes in.
The voice routing
One Twilio number serves two completely different AI experiences:
pythondef twilio_voice_incoming(request):
caller = request.POST.get('From')

# Check if caller is verified owner
owner_plan = UserPlan.objects.filter(
    user=workspace.owner,
    mobile_verified=True
).first()

if owner_plan and normalize(caller) == normalize(owner_plan.mobile_number):
    # Route to Manager AI (private mode)
    return redirect_to_manager_ai(workspace)
else:
    # Route to customer RAG bot (public mode)
    return customer_rag_response(workspace)

The Manager AI
The owner's AI Manager has 50+ executive actions registered:
pythonACTION_HANDLERS = {
'check_owner_emails_now': check_owner_emails_now_action,
'create_report': create_report,
'query_external_database': query_external_database,
'setup_ai_call_center': setup_ai_call_center,
'analyse_database_for_automation': analyse_database_for_automation,
# ... 45 more actions
}
When the owner sends "How many orders today?" on Telegram, the system parses the intent, executes the database query, and returns a formatted answer — all in the owner's language.
Performance on 4GB RAM
Neo4j: ~800MB
PostgreSQL: ~400MB

Redis: ~200MB
Gunicorn: ~600MB
Celery workers: ~400MB
Total: ~2.4GB (leaves headroom)
The whole system runs on a $8/month Contabo VPS.
Full docs: docs.ragleap.com
Try it: ragleap.com (7-day free trial, bring your own API key)

How We Built an AI Agent to Automate Business Workflows

RagLeap — Fri, 10 Apr 2026 16:14:17 +0000

How We Built an AI Agent to Automate Business Workflows

Most businesses still rely on manual workflows to manage sales, customer interactions, and operations.

As developers, we kept asking:
What if AI could handle these repetitive tasks?

That’s what led us to start building Ragleap — an AI-powered platform designed to automate business workflows using intelligent agents.

The Idea

The goal was simple:

Reduce manual effort
Automate repetitive business tasks
Make AI useful for real-world operations

Instead of building just another chatbot, we focused on creating an AI agent that can take actions, not just respond.

Tech Stack

We used a flexible and scalable stack:

Backend: Django
Database: PostgreSQL / MySQL
AI Integration: Multi-model API support (LLMs)
Automation Layer: Custom workflow engine

The idea was to keep the system modular so it can integrate with different APIs and services.

How It Works

At a high level, the system follows this flow:

User provides input (task or request)
AI processes the intent
System maps it to an action
Workflow gets executed automatically

Example Use Cases

Automating sales workflows
Managing customer interactions
Triggering business processes based on events

Instead of requiring manual setup, we are working toward an AI-assisted setup experience.

Challenges We Faced

Building AI agents that actually do things (not just chat) comes with challenges:

1. API Integration

Handling multiple external services and making them work reliably together.

2. Context Understanding

Ensuring the AI understands business intent correctly.

3. Workflow Execution

Mapping AI decisions to real-world actions without breaking the system.

4. Scalability

Designing the system to handle multiple users and workflows efficiently.

What We Learned

AI is powerful, but execution is the hard part
Real-world automation requires reliability, not just intelligence
Simplicity in UX is more important than adding features

What’s Next

We’re continuing to improve:

AI decision-making
Workflow automation
Integration capabilities

We’re building this at https://ragleap.com — would love feedback from the developer community 🙌