RudraDB-Opin Documentation

# No dimension specification needed!
db = rudradb.RudraDB()  # Auto-detects from first embedding

# OpenAI embeddings (1536D) - Auto-detected
openai_embedding = get_openai_embedding("text")
db.add_vector("openai_doc", openai_embedding)
print(f"Auto-detected: {db.dimension()}D")  # 1536

# Switch to Sentence Transformers (384D)
db2 = rudradb.RudraDB()  # Fresh auto-detection
st_embedding = sentence_transformer.encode("text")
db2.add_vector("st_doc", st_embedding)
print(f"Auto-detected: {db2.dimension()}D")  # 384

# Just add documents with rich metadata
db.add_vector("ai_intro", embedding, {
    "category": "AI",
    "difficulty": "beginner", 
    "tags": ["ai", "introduction"],
    "type": "concept"
})

db.add_vector("ml_advanced", embedding, {
    "category": "AI",
    "difficulty": "advanced",
    "tags": ["ml", "algorithms"],
    "type": "concept"
})

# Auto-creates relationships:
# - Semantic (same category)
# - Temporal (beginner → advanced)
# - Associative (shared tags)

import numpy as np

# Basic vector addition
embedding = np.random.rand(384).astype(np.float32)
db.add_vector("doc_1", embedding, {
    "title": "Machine Learning Basics",
    "author": "Dr. Smith", 
    "category": "education",
    "tags": ["ml", "tutorial"],
    "difficulty": "beginner"
})

# Traditional similarity search
results = db.search(query_embedding, rudradb.SearchParams(
    top_k=5,
    include_relationships=False
))

# Relationship-aware search
enhanced_results = db.search(query_embedding, rudradb.SearchParams(
    top_k=10,
    include_relationships=True,  # 🔥 Enable relationship intelligence
    max_hops=2,                 # Multi-hop discovery
    relationship_weight=0.3     # Balance similarity + relationships
))

# Discovers 2x more relevant results!

# Find documents connected through relationship chains
connected = db.get_connected_vectors("starting_doc", max_hops=2)

for vector, hop_count in connected:
    connection_type = "Direct" if hop_count == 0 else f"{hop_count}-hop"
    print(f"📄 {vector['id']}: {connection_type} connection")

# Example chain: A →(semantic)→ B →(causal)→ C

rudradb.RudraDB(dimension=None, config=None)

params = rudradb.SearchParams(
    top_k=10,                          # Number of results
    include_relationships=True,         # Enable relationship search
    max_hops=2,                        # Maximum relationship hops
    similarity_threshold=0.1,          # Minimum similarity score
    relationship_weight=0.3,           # Relationship influence (0.0-1.0)
    relationship_types=["semantic"]    # Filter relationship types
)

import openai
import rudradb
import numpy as np

# Auto-detects OpenAI's 1536D embeddings
db = rudradb.RudraDB()

# Add document with OpenAI embedding
response = openai.Embedding.create(
    model="text-embedding-ada-002",
    input="Your document text here"
)

embedding = np.array(response['data'][0]['embedding'], dtype=np.float32)
db.add_vector("doc1", embedding, {"source": "openai"})

print(f"Auto-detected dimension: {db.dimension()}D")  # 1536

from sentence_transformers import SentenceTransformer
import rudradb

# Auto-detects any model's dimensions
model = SentenceTransformer('all-MiniLM-L6-v2')  # 384D
db = rudradb.RudraDB()

# Batch processing
texts = ["Document 1", "Document 2", "Document 3"]
embeddings = model.encode(texts)

for i, (text, embedding) in enumerate(zip(texts, embeddings)):
    db.add_vector(f"doc_{i}", embedding.astype(np.float32), {"text": text})

print(f"Auto-detected dimension: {db.dimension()}D")  # 384

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import CharacterTextSplitter
import rudradb

# Setup
embeddings = HuggingFaceEmbeddings()
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
db = rudradb.RudraDB()  # Auto-detects embedding dimensions

# Process documents
documents = [...]  # Your documents
chunks = text_splitter.split_documents(documents)

# Add with relationship building
for i, chunk in enumerate(chunks):
    embedding = embeddings.embed_query(chunk.page_content)
    db.add_vector(f"chunk_{i}", np.array(embedding, dtype=np.float32), {
        "content": chunk.page_content,
        "source": chunk.metadata.get("source")
    })

# Enhanced RAG search
def rag_search(query):
    query_embedding = embeddings.embed_query(query)
    results = db.search(np.array(query_embedding, dtype=np.float32), 
                       rudradb.SearchParams(include_relationships=True))
    return results

stats = db.get_statistics()
usage = stats['capacity_usage']

print(f"Vectors: {stats['vector_count']}/{rudradb.MAX_VECTORS}")
print(f"Relationships: {stats['relationship_count']}/{rudradb.MAX_RELATIONSHIPS}")
print(f"Vector usage: {usage['vector_usage_percent']:.1f}%")

# Upgrade recommendation
if usage['vector_usage_percent'] > 80:
    print("💡 Consider upgrading to full RudraDB for production scale!")

# 1. Export your data
data = db.export_data()
with open('my_data.json', 'w') as f:
    json.dump(data, f)

# 2. Upgrade package
# pip uninstall rudradb-opin
# pip install rudradb

# 3. Import to production scale
import rudradb  # Now the full version!
new_db = rudradb.RudraDB()  # 100,000+ vector capacity
new_db.import_data(data)    # Same API, unlimited scale!