Framework Integrations

Memvid supports two integration styles:

SDK adapters for framework-native tools and retrievers
REST API integrations for platforms that work best with HTTP

One Memory, Many Surfaces. Use SDK adapters with .mv2 files, or use cloud memories through https://api.memvid.com for API-first platforms.

Quick Comparison

Integration	Type	Language	Best For
LangChain	SDK adapter	Python, Node.js	Agents, chains, RAG
LlamaIndex	SDK adapter	Python, Node.js	RAG pipelines, indexing
Vercel AI	SDK adapter	Node.js	Next.js, streaming
OpenAI	SDK adapter	Python, Node.js	Direct API, function calling
Google ADK	SDK adapter	Python, Node.js	Gemini, ADK agents
AutoGen	SDK adapter	Python, Node.js	Multi-agent systems
CrewAI	SDK adapter	Python, Node.js	Agent crews
Semantic Kernel	SDK adapter	Python, Node.js	Enterprise AI, Azure
Haystack	SDK adapter	Python	Search pipelines
API Integration Patterns	REST API	Any HTTP runtime	Shared production patterns
n8n	REST API	No-code / low-code	Workflow automation
Replit	REST API	Node.js, Python	Cloud prototyping and apps
Lovable	REST API	TypeScript	Productized AI app builders
v0	REST API	Next.js	Generated app frontends

Choosing the Right Integration

I'm building a RAG application

Recommended: LangChain or LlamaIndexUse the tools to search your knowledge base and build RAG pipelines.

# LangChain with tools
from memvid_sdk import use
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

mem = use('langchain', 'knowledge.mv2')
agent = create_react_agent(ChatOpenAI(model="gpt-4o"), mem.tools)
result = agent.invoke({"messages": [{"role": "user", "content": "What is..."}]})

# Or use find() + ask() directly
results = mem.find("search query", k=5)
answer = mem.ask("What is the main concept?")

I'm building an AI agent

Recommended: LangChain, AutoGen, or CrewAIThese frameworks excel at agent orchestration with tool use.

# LangChain Agent
from langgraph.prebuilt import create_react_agent
mem = use('langchain', 'knowledge.mv2')
agent = create_react_agent(model, mem.tools)

# AutoGen
mem = use('autogen', 'knowledge.mv2')
assistant = AssistantAgent("helper", llm_config={"tools": mem.tools})

I'm using Next.js / Vercel

Recommended: Vercel AI SDKNative streaming support and seamless integration with Next.js.

import { use } from '@memvid/sdk';
import { streamText } from 'ai';

const mem = await use('vercel-ai', 'knowledge.mv2');

export async function POST(req: Request) {
  const result = await streamText({
    model: openai('gpt-4o'),
    tools: mem.tools,
    messages: await req.json(),
  });
  return result.toDataStreamResponse();
}

I want direct OpenAI/Gemini function calling

Recommended: OpenAI or Google ADKUse the native function calling APIs without framework overhead.

# OpenAI
mem = use('openai', 'knowledge.mv2')
response = client.chat.completions.create(
    model="gpt-4o",
    tools=mem.tools,
    messages=[...]
)

# Google Gemini
mem = use('google-adk', 'knowledge.mv2')
chat = client.chats.create(
    model="gemini-2.0-flash",
    config=types.GenerateContentConfig(tools=[mem.tools])
)

I'm building enterprise AI with Azure

Recommended: Semantic KernelMicrosoft’s SDK with enterprise features and Azure integration.

mem = use('semantic-kernel', 'knowledge.mv2')
kernel.add_plugin(mem.tools, "memvid")

I'm automating workflows with no-code tools

Recommended: n8n and LovableUse direct REST calls to Memvid from HTTP request steps and backend actions.

curl -X POST https://api.memvid.com/v1/memories/{MEMORY_ID}/ask \
  -H "Authorization: Bearer mv2_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question":"What does this process do?"}'

I'm prototyping quickly in hosted app builders

Recommended: Replit and v0Route your app’s backend requests to Memvid API and keep keys server-side.

const res = await fetch("https://api.memvid.com/v1/memories/{MEMORY_ID}/find", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.MEMVID_API_KEY}` },
  body: JSON.stringify({ query: "search query", topK: 5 }),
});

Universal Features

All adapters provide these core capabilities:

Tools / Functions

Every adapter exposes three primary tools:

Tool	Description
`memvid_put`	Store documents in memory
`memvid_find`	Search for relevant documents
`memvid_ask`	Ask questions with RAG synthesis

# Access tools (framework-specific format)
tools = mem.tools

Direct API Access

You can always bypass the adapter and use the core API directly:

# These work with any adapter
results = mem.find('search query', k=10)
answer = mem.ask('What is machine learning?')
timeline = mem.timeline(limit=50)
stats = mem.stats()

Installation

Each adapter requires its framework to be installed:

Node.js
Python

# Core SDK
npm install @memvid/sdk

# Framework dependencies (install what you need)
npm install @langchain/core @langchain/openai   # LangChain
npm install llamaindex                          # LlamaIndex
npm install ai @ai-sdk/openai                   # Vercel AI
npm install openai                              # OpenAI
npm install @google/generative-ai              # Google ADK

# Core SDK
pip install memvid-sdk

# Framework dependencies (install what you need)
pip install "memvid-sdk[langchain]"        # LangChain
pip install "memvid-sdk[llamaindex]"       # LlamaIndex
pip install "memvid-sdk[openai]"           # OpenAI
pip install google-genai                   # Google ADK
pip install "memvid-sdk[autogen]"          # AutoGen
pip install "memvid-sdk[crewai]"           # CrewAI
pip install "memvid-sdk[semantic-kernel]"  # Semantic Kernel
pip install "memvid-sdk[haystack]"         # Haystack

# Or install all integrations:
pip install "memvid-sdk[full]"

Adapter Architecture

Each adapter:

Wraps the core Memvid API
Formats tools/retrievers for the specific framework
Handles framework-specific types and conventions
Provides seamless integration without lock-in

Performance Comparison

All adapters have similar performance since they use the same core engine:

Operation	Latency	Notes
`find()`	< 5ms	Hybrid search (lex + vec)
`ask()`	20-200ms	Depends on LLM response time
`put()`	< 40ms	With embedding generation
File Open	< 10ms	Cold start

The framework overhead is minimal (< 1ms per operation).

Examples Gallery

RAG Chatbot

Build a chatbot with persistent memory using LangChain

Document Q&A

Create a document Q&A system with LlamaIndex

Knowledge Base

Build a searchable company knowledge base

Research Assistant

Create an AI research assistant for papers

Framework Guides

LangChain

Agents, chains, retrievers

LlamaIndex

RAG pipelines, query engines

Vercel AI

Next.js, streaming

OpenAI

Function calling

Google ADK

Gemini, ADK agents

AutoGen

Multi-agent systems

CrewAI

Agent crews

Semantic Kernel

Enterprise AI

Haystack

Search pipelines

API Platform Guides

API Integration Patterns

Shared contracts, retries, polling, and smoke tests

n8n

Workflow automation with HTTP Request nodes

Replit

Cloud app integration with server-side fetch

Lovable

Product app builder integration via backend API calls

v0

Next.js route handlers and server actions

​Quick Comparison

​Choosing the Right Integration

​Universal Features

​Tools / Functions

​Direct API Access

​Installation

​Adapter Architecture

​Performance Comparison

​Examples Gallery

RAG Chatbot

Document Q&A

Knowledge Base

Research Assistant

​Framework Guides

LangChain

LlamaIndex

Vercel AI

OpenAI

Google ADK

AutoGen

CrewAI

Semantic Kernel

Haystack

​API Platform Guides

API Integration Patterns

n8n

Replit

Lovable

v0

Quick Comparison

Choosing the Right Integration

Universal Features

Tools / Functions

Direct API Access

Installation

Adapter Architecture

Performance Comparison

Examples Gallery

Framework Guides

API Platform Guides