Migration from VectorDB

Move from Pinecone, Weaviate, or ChromaDB to Engramma. Map concepts, export data, and start using cognitive memory in under an hour.

What you'll build

A migration script that moves your vectors and metadata from your current vector database to Engramma — plus a concept mapping to understand what you gain.

Prerequisites

Requirement	Details
Account	Starter tier or above (for bulk import)
API key	From your dashboard
SDK	Python or JavaScript
Existing data	An active Pinecone, Weaviate, or ChromaDB instance
Time	~30-60 minutes (depends on data volume)

Concept mapping

Your existing knowledge translates directly:

Vector DB concept	Engramma equivalent	What changes
Vector/Embedding	Pattern	Engramma also stores text, not just vectors
Index/Collection	Memory Space	One per API key (or use metadata for namespaces)
Namespace	Metadata filter	Use `metadata_filter` to segment data
Cosine similarity	Confidence score	Confidence combines 3 pathways, not just cosine
Upsert	Store	Same operation, richer result
Query	Retrieve	Returns confidence + pathway + causal chain
Metadata	Metadata	Carries over directly
—	Consolidation	New: memory quality improves over time
—	Causal links	New: facts connect automatically
—	Explainability	New: every result has a reason

Steps

Export from your current database

Extract your vectors, text, and metadata from Pinecone, Weaviate, or ChromaDB.

Transform to Engramma format

Map your data to Engramma's store format. If you have raw text, use the text endpoint. If you only have embeddings, use the embedding endpoint.

Import into Engramma

Batch-store your data into Engramma.

Consolidate

Run a consolidation cycle to let the engine organize, deduplicate, and build causal links.

Validate

Run your existing queries against Engramma and compare results.

Migration from Pinecone

import os
import pinecone
from engramma_cloud import EngrammaClient

# Source: Pinecone
pinecone.init(api_key=os.environ["PINECONE_API_KEY"])
index = pinecone.Index("my-index")

# Destination: Engramma
engramma = EngrammaClient(api_key=os.environ["ENGRAMMA_API_KEY"])

# Export from Pinecone (paginated)
def export_pinecone(namespace="", batch_size=100):
    results = index.query(
        vector=[0.0] * 1536,  # dummy vector to fetch all
        top_k=batch_size,
        include_metadata=True,
        include_values=True,
        namespace=namespace
    )
    return results.matches

# Import into Engramma
matches = export_pinecone()
for match in matches:
    text = match.metadata.get("text", "")
    if text:
        # Prefer text store (re-encodes with Engramma's encoding)
        engramma.store(text, metadata=match.metadata)
    else:
        # Fallback: store raw embedding
        engramma.store_embedding(
            embedding=match.values,
            metadata=match.metadata
        )

print(f"Migrated {len(matches)} vectors from Pinecone")

# Consolidate after import
result = engramma.consolidate()
print(f"Consolidated: {result.merged} merged, {result.pruned} pruned")

Migration from Weaviate

import os
import weaviate
from engramma_cloud import EngrammaClient

# Source: Weaviate
weaviate_client = weaviate.Client("http://localhost:8080")

# Destination: Engramma
engramma = EngrammaClient(api_key=os.environ["ENGRAMMA_API_KEY"])

# Export from Weaviate
result = weaviate_client.query.get(
    "Document", ["content", "title", "category"]
).with_limit(1000).do()

documents = result["data"]["Get"]["Document"]

# Import into Engramma
for doc in documents:
    engramma.store(
        doc["content"],
        metadata={
            "title": doc.get("title"),
            "category": doc.get("category"),
            "source": "weaviate_migration"
        }
    )

print(f"Migrated {len(documents)} documents from Weaviate")

# Consolidate
result = engramma.consolidate()
print(f"Consolidated: {result.merged} merged, {result.pruned} pruned")

Migration from ChromaDB

import os
import chromadb
from engramma_cloud import EngrammaClient

# Source: ChromaDB
chroma = chromadb.Client()
collection = chroma.get_collection("my-collection")

# Destination: Engramma
engramma = EngrammaClient(api_key=os.environ["ENGRAMMA_API_KEY"])

# Export from ChromaDB
results = collection.get(
    include=["documents", "metadatas", "embeddings"]
)

# Import into Engramma
for i, doc in enumerate(results["documents"]):
    metadata = results["metadatas"][i] if results["metadatas"] else {}
    metadata["source"] = "chromadb_migration"
    
    if doc:
        engramma.store(doc, metadata=metadata)
    elif results["embeddings"] and results["embeddings"][i]:
        engramma.store_embedding(
            embedding=results["embeddings"][i],
            metadata=metadata
        )

print(f"Migrated {len(results['documents'])} items from ChromaDB")

# Consolidate
result = engramma.consolidate()
print(f"Consolidated: {result.merged} merged, {result.pruned} pruned")

Validating your migration

After importing, verify that your existing queries work as expected:

# Run your most important queries and compare
test_queries = [
    "What is our deployment process?",
    "Who is responsible for the billing system?",
    "What are the main risks in Q2?"
]

for query in test_queries:
    results = engramma.retrieve(query, top_k=3)
    print(f"\nQuery: {query}")
    for r in results:
        print(f"  [{r.confidence:.2f}|{r.pathway}] {r.text[:80]}...")

What you gain after migration

Before (Vector DB)	After (Engramma)
Cosine similarity only	Three pathways + Confidence Router
No explanation	Full explainability at 3 levels
Static storage	Self-improving via consolidation
Manual deduplication	Automatic merging
No causal reasoning	"What if?" and "why?" queries
Same behavior always	Regime-adaptive behavior

Tip

After migration, give Engramma a few days of normal usage. Consolidation cycles will build causal links, strengthen important memories, and prune duplicates — things your vector database never did.

Next steps

Your First Memory — Quick introduction to the Engramma API
How It Works — Understand the 10-phase cognitive cycle
Consolidation — How your migrated data improves over time