The Problem

You’re building an AI app. You need semantic search for RAG. Everyone tells you:

“Use Pinecone” ($70/month, 100+ lines of code)
“Use Weaviate” (another service to manage)
“Use pgvector” (slow, complex tuning)

But you already have Redis for cache, sessions, and queues.

What if I told you: Redis is also a vector database?

⚡ Build RAG in 50 Lines

50

Lines of Code

$0

API Costs

1

Service (Redis)

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 is Better

🚀 New: Automatic Index Creation

Vector indexes are now created automatically during init_beanis(). No manual redis-cli commands needed! Just define your model with VectorField() and you're ready to search.

Compared to Pinecone

❌ Pinecone

Requires API key + billing
100+ lines of setup code
Separate service to manage
$70+/month for production
Rate limits, quotas
40ms query latency

✅ Beanis + Redis

No API keys needed
50 lines total
Automatic index creation
Use Redis you already have
$0 extra cost
No limits
15ms query latency

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)

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

Benchmarked with 10,000 documents:

Vector DB	Query Time	Setup	Cost	Lines of Code
Beanis + Redis	15ms	Docker run	$0	50
Pinecone	40ms	API keys, billing	$70+/month	100+
Weaviate	35ms	Separate service	Self-host cost	80+
pgvector	200ms	PostgreSQL extension	DB cost	60+

Beanis is faster AND simpler.

The “Already Using Redis” Advantage

Most companies already use Redis for:

✅ Caching
✅ Session storage
✅ Job queues
✅ Rate limiting

Now add:

✅ Vector search (for RAG/AI)

One service for everything. No need to add Pinecone, Weaviate, or pgvector. Lower ops complexity, lower cost.

Architecture Simplification

Before (4 services):

Redis      → Cache, sessions
PostgreSQL → User data
Pinecone   → Vector search ($70/month)
Your App   → Business logic

After (2 services):

Redis      → Cache, sessions, vectors!
PostgreSQL → User data
Your App   → Business logic

Savings:

1 fewer service to manage
$70-500/month saved
Simpler deployment
Faster (data locality)

Advanced Features

Multimodal Search

Jina v4 supports text + images!

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(...)

Find images with text. Find text with images. Magic!

Hybrid Search

Combine vector similarity with metadata filters:

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

Production Scaling

# Use Redis Cluster
redis_client = redis.RedisCluster(
    host="redis-cluster.example.com"
)

# Tune HNSW for your use case
VectorField(
    dimensions=1024,
    algorithm="HNSW",
    m=32,  # More connections = better recall
    ef_construction=400  # Higher = better index quality
)

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?

Simplicity - Define models like Pydantic, search like it’s magic
Performance - Redis is fast, Beanis doesn’t slow it down
No lock-in - It’s just Redis, move anywhere
Familiar - If you know Pydantic, you know Beanis
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