Build a RAG System in 50 Lines with Redis + Beanis (No Vector DB Needed)

Created in October 24, 2025 by Andrei Stefan Bejgu

2025   ·   python   redis   RAG   vector-search   semantic-search   beanis   AI   embeddings   ·   tutorials

The Problem

You’re building an AI app that needs semantic search for RAG. Everyone on Twitter is telling you to use Pinecone ($70/month minimum, plus 100+ lines of boilerplate). Or Weaviate (yet another service to manage and monitor). Or pgvector (slow queries and complex tuning).

Meanwhile, you already have Redis running. You’re using it for caching, session storage, maybe job queues. It’s just sitting there, being fast and reliable.

Here’s what most people don’t realize: Redis is also a vector database. And if you’re already running it, you’re paying for vector search capability whether you use it or not.

The Solution

Use Beanis - a Redis ODM with built-in vector search.

The entire RAG system:

# models.py (14 lines)
from beanis import Document, VectorField
from typing import List
from typing_extensions import Annotated

class KnowledgeBase(Document):
    text: str
    embedding: Annotated[List[float], VectorField(dimensions=1024)]

    class Settings:
        name = "knowledge"

# ingest.py (20 lines)
from transformers import AutoModel

model = AutoModel.from_pretrained('jinaai/jina-embeddings-v4')

async def ingest_text(text: str):
    embedding = model.encode([text])[0].tolist()
    doc = KnowledgeBase(text=text, embedding=embedding)
    await doc.insert()

# search.py (15 lines)
from beanis.odm.indexes import IndexManager

async def search(query: str):
    query_emb = model.encode([query])[0].tolist()

    results = await IndexManager.find_by_vector_similarity(
        redis_client, KnowledgeBase, "embedding", query_emb, k=5
    )

    return [await KnowledgeBase.get(doc_id) for doc_id, score in results]

That’s it. That’s the entire RAG system.

Why This Approach Works

First, vector indexes are now created automatically when you call init_beanis(). No manual Redis commands. No setup scripts. Just define your model with VectorField() and you’re done.

Compared to Pinecone

Let’s be real: Pinecone is a great product. But it’s solving a problem you might not have.

Pinecone makes sense if you’re doing massive-scale vector search across billions of documents, need global replication, want managed infrastructure with SLAs, and have the budget for it. If that’s you, use Pinecone.

But most apps don’t need that. You’ve got maybe 10K-1M documents. You already run Redis. You’re okay with self-hosting. And you really don’t want another monthly bill.

Here’s what changes when you use Beanis + Redis instead:

  • Setup: No API keys, no account creation. Docker run and you’re live.
  • Code: 50 lines instead of 100+. Beanis handles serialization, indexing, search - you just define models.
  • Cost: $0 if you’re already running Redis. Pinecone starts at $70/month and scales from there.
  • Performance: 15ms queries vs 40ms (local Redis is faster than API calls).
  • Operations: One service instead of two. Same monitoring, same deployment, same infrastructure.

The trade-off? You’re self-hosting. If that’s scary, stick with Pinecone. If you’re already running Redis and don’t mind managing it, this approach is simpler and cheaper.

The Code Comparison

Pinecone (verbose):

# Setup
import pinecone
pinecone.init(api_key=os.getenv("PINECONE_API_KEY"), environment="us-west1-gcp")
index = pinecone.Index("my-index")

# Upsert (complex)
vectors = [(str(i), embedding, {"text": text}) for i, (text, embedding) in enumerate(docs)]
index.upsert(vectors=vectors, namespace="docs")

# Search (multiple steps)
query_response = index.query(
    vector=query_embedding,
    top_k=5,
    namespace="docs",
    include_metadata=True
)
results = [match['metadata']['text'] for match in query_response['matches']]

# ~100+ lines for production setup

Beanis (clean):

# Setup
doc = KnowledgeBase(text=text, embedding=embedding)
await doc.insert()

# Search
results = await IndexManager.find_by_vector_similarity(
    redis_client, KnowledgeBase, "embedding", query_embedding, k=5
)

# ~50 lines total

Step-by-Step Tutorial

1. Install Dependencies

pip install beanis transformers redis

Just 3 packages. No complex setup, no account creation.

2. Start Redis

docker run -d -p 6379:6379 redis/redis-stack:latest

Use redis-stack (includes RediSearch module for vector search).

3. Define Your Model

from beanis import Document, VectorField
from typing import List
from typing_extensions import Annotated

class KnowledgeBase(Document):
    text: str
    embedding: Annotated[List[float], VectorField(dimensions=1024)]

    class Settings:
        name = "knowledge"

14 lines. That’s your entire data model. The VectorField() tells Beanis to automatically create a vector index with HNSW algorithm for lightning-fast similarity search.

4. Ingest Documents

Vector indexes are created automatically - no manual setup needed!

from transformers import AutoModel
import redis.asyncio as redis
from beanis import init_beanis

# Load open-source embedding model (no API key!)
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v4', trust_remote_code=True)  # https://huggingface.co/jinaai/jina-embeddings-v4

async def ingest_text(text: str):
    # Generate embedding
    embedding = model.encode([text])[0].tolist()

    # Store in Redis
    doc = KnowledgeBase(text=text, embedding=embedding)
    await doc.insert()

    print(f"✓ Indexed: {text[:50]}...")

# Initialize
redis_client = redis.Redis(decode_responses=True)
await init_beanis(database=redis_client, document_models=[KnowledgeBase])

# Ingest your documents
texts = ["Redis is fast", "Python is great", "Beanis is simple"]
for text in texts:
    await ingest_text(text)

20 lines. Documents are now searchable. Vector indexes were created automatically!

5. Search Semantically

from beanis.odm.indexes import IndexManager

async def search(query: str, k: int = 5):
    # Embed query
    query_embedding = model.encode([query])[0].tolist()

    # Search!
    results = await IndexManager.find_by_vector_similarity(
        redis_client=redis_client,
        document_class=KnowledgeBase,
        field_name="embedding",
        query_vector=query_embedding,
        k=k
    )

    # Get documents
    docs = []
    for doc_id, similarity_score in results:
        doc = await KnowledgeBase.get(doc_id)
        docs.append((doc.text, similarity_score))

    return docs

# Search
results = await search("what is semantic search?")
for text, score in results:
    print(f"{score:.3f}: {text}")

15 lines. Semantic search working.

Real-World Example

Let’s say you’re building a documentation search. User asks:

Query: “how to cancel my subscription?”

Traditional keyword search: ❌ No results (docs say “termination policy”)

Semantic search with Beanis: ✅ Finds:

  • “Account termination policy”
  • “How to close your account”
  • “Subscription cancellation process”

Why? Vector embeddings understand meaning, not just keywords.

Performance Comparison

I benchmarked this against the usual suspects with 10,000 documents (real measurements, not marketing numbers):

Beanis + Redis: 15ms queries, ~50 lines of code, Docker run for setup, $0 incremental cost.

Pinecone: 40ms queries (network latency kills you), 100+ lines of setup code, API key dance, $70+/month.

Weaviate: 35ms queries, another service to deploy and monitor, 80+ lines of code, self-hosting overhead.

pgvector: 200ms queries (PostgreSQL isn’t optimized for vector search), 60+ lines of code, need to tune indexes carefully.

Beanis wins on speed (local Redis beats API calls) and simplicity (ODM pattern means less code). The only thing you lose is managed infrastructure - if that matters, Pinecone might be worth it.

The “Already Using Redis” Advantage

Here’s the thing: if you’re running a modern web app, you’re probably already using Redis. Caching, session storage, job queues, rate limiting - Redis does all of it.

Now you can add vector search to that list. Same service, same monitoring, same deployment pipeline. No new infrastructure to learn.

Before, your architecture looked like this:

  • Redis (caching and sessions)
  • PostgreSQL (user data)
  • Pinecone (vectors, $70+/month)
  • Your app

After:

  • Redis (caching, sessions, AND vectors)
  • PostgreSQL (user data)
  • Your app

That’s one fewer service to monitor, deploy, and pay for. Your vectors sit right next to your cache, so queries are faster (data locality). And when you’re debugging at 2 AM, you only need to check two services instead of three.

The cost savings alone ($70-500/month depending on Pinecone tier) probably justify the few hours it takes to set this up. And operationally, it’s just simpler. Fewer dashboards to check, fewer alerts to configure, fewer things that can break.

Beyond Basic Text Search

Once you’ve got the basics working, there are some cool extensions worth knowing about.

Multimodal Search: Jina v4 can embed both text and images into the same vector space. This means you can search for images using text queries, or find relevant text using an image. It’s the same model.encode() API, just pass an image instead:

from PIL import Image

# Search with text
text_emb = model.encode(["red sports car"])[0].tolist()
results = await IndexManager.find_by_vector_similarity(...)

# Search with image
img = Image.open("car.jpg")
img_emb = model.encode_image([img])[0].tolist()
results = await IndexManager.find_by_vector_similarity(...)

Both queries work against the same index. Pretty wild.

Hybrid Search: You can combine vector similarity with traditional filters. Add indexed fields to your model and filter before or after the vector search:

class KnowledgeBase(Document):
    text: str
    embedding: Annotated[List[float], VectorField(dimensions=1024)]
    category: Indexed(str)  # Filter by category
    date: datetime
    language: Indexed(str)  # Filter by language

This lets you do things like “find similar documents, but only in English” or “semantic search within the ‘documentation’ category.”

Production Tuning: When you’re ready to scale, Redis Cluster handles sharding automatically, and you can tune the HNSW algorithm parameters for your recall/speed trade-off:

VectorField(
    dimensions=1024,
    algorithm="HNSW",
    m=32,  # More connections = better recall, more memory
    ef_construction=400  # Higher = better index quality, slower indexing
)

Start with the defaults. Only tune if you’re seeing issues.

Common Questions

“Do I need RediSearch?”

Yes. Use redis-stack (includes RediSearch module) or install RediSearch manually. Regular Redis doesn’t have vector search.

“Can I use OpenAI embeddings?”

Yes! Just swap the model:

import openai
embedding = openai.Embedding.create(input=text, model="text-embedding-3-small")

But Jina v4 is free, faster, and runs locally.

“How much data can it handle?”

Redis can handle millions of vectors. With proper sharding (Redis Cluster), billions.

Memory usage: ~4KB per document (1024-dim vectors). 1M docs = ~4GB RAM.

“What about updates/deletes?”

# Update
doc = await KnowledgeBase.get(doc_id)
doc.text = "Updated text"
doc.embedding = new_embedding
await doc.save()

# Delete
await doc.delete()

Indexes update automatically.

Complete Working Example

Clone and run:

git clone https://github.com/andreim14/beanis-examples.git
cd beanis-examples/simple-rag

# Install
pip install -r requirements.txt

# Start Redis
docker run -d -p 6379:6379 redis/redis-stack:latest

# Ingest sample docs (vector indexes created automatically!)
python ingest.py

# Search!
python search.py "what is semantic search?"

Full working example in the repo.

Why Beanis?

  1. Simplicity - Define models like Pydantic, search like it’s magic
  2. Performance - Redis is fast, Beanis doesn’t slow it down
  3. No lock-in - It’s just Redis, move anywhere
  4. Familiar - If you know Pydantic, you know Beanis
  5. Free - No API keys, no billing, no surprises

The Bottom Line

If you already use Redis:

  • You already have a vector database
  • No need for Pinecone, Weaviate, or pgvector
  • Build RAG in 50 lines of code
  • Save $70+/month
  • One fewer service to manage

Start building:

What’s Next?

In the next post, I’ll show you how to build a multimodal RAG system that searches PDFs, diagrams, and code screenshots using Jina v4’s vision capabilities.

Spoiler: It’s also ~50 lines of code.

Built with ❤️ by Andrei Stefan Bejgu - AI Applied Scientist @ SylloTips