DEV Community: RagLeap

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 🙌