OpenAI SDK

Integrate Memvid with the OpenAI SDK to use function calling with your knowledge base. The openai adapter provides function schemas formatted for OpenAI’s chat completions API.

Node.js
Python

Installation

npm install @memvid/sdk openai

Quick Start

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

// Open with OpenAI adapter
const mem = await use('openai', 'knowledge.mv2');

// Access function schemas
const functions = mem.functions;  // Array of function schemas

Installation

pip install memvid-sdk openai

Quick Start

from memvid_sdk import use

# Open with OpenAI adapter
mem = use('openai', 'knowledge.mv2')

# Access function schemas
functions = mem.functions  # OpenAI function schemas

Available Functions

The OpenAI adapter provides three functions:

Function	Description
`memvid_put`	Store documents in memory with title, label, and text
`memvid_find`	Search for relevant documents by query
`memvid_ask`	Ask questions with RAG-style answer synthesis

Function Calling Example

Node.js
Python

import { use } from '@memvid/sdk';
import OpenAI from 'openai';

// Get Memvid functions
const mem = await use('openai', 'knowledge.mv2');
const functions = mem.functions;

// Create OpenAI client
const client = new OpenAI();

const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
  { role: 'system', content: 'You are a helpful assistant with access to a knowledge base.' },
  { role: 'user', content: 'Search for information about authentication' },
];

// Create completion with function calling
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages,
  tools: functions.map((f: any) => ({ type: 'function' as const, function: f })),
  tool_choice: 'auto',
});

// Handle function calls
const message = response.choices[0].message;
if (message.tool_calls) {
  for (const toolCall of message.tool_calls) {
    const funcName = toolCall.function.name;
    const funcArgs = JSON.parse(toolCall.function.arguments);

    let result: any;
    if (funcName === 'memvid_find') {
      result = await mem.find(funcArgs.query, { k: funcArgs.top_k || 5 });
    } else if (funcName === 'memvid_put') {
      result = await mem.put({
        title: funcArgs.title,
        label: funcArgs.label,
        text: funcArgs.text,
      });
    } else if (funcName === 'memvid_ask') {
      result = await mem.ask(funcArgs.question, { mode: funcArgs.mode || 'auto' });
    }

    console.log(`Function ${funcName} result:`, result);
  }
}

from memvid_sdk import use
import openai
import json

# Get Memvid functions
mem = use('openai', 'knowledge.mv2')
functions = mem.functions

# Create completion with function calling
client = openai.OpenAI()

messages = [
    {"role": "system", "content": "You are a helpful assistant with access to a knowledge base."},
    {"role": "user", "content": "Search for information about authentication"}
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=[{"type": "function", "function": f} for f in functions],
    tool_choice="auto"
)

# Handle function calls
message = response.choices[0].message
if message.tool_calls:
    for tool_call in message.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)

        # Execute the function
        if func_name == "memvid_find":
            result = mem.find(func_args["query"], k=func_args.get("top_k", 5))
        elif func_name == "memvid_put":
            result = mem.put(
                title=func_args["title"],
                label=func_args["label"],
                text=func_args["text"]
            )
        elif func_name == "memvid_ask":
            result = mem.ask(func_args["question"], mode=func_args.get("mode", "auto"))

        print(f"Function {func_name} result: {result}")

Complete Conversation Loop

Node.js
Python

import { use } from '@memvid/sdk';
import OpenAI from 'openai';

const mem = await use('openai', 'knowledge.mv2');
const functions = mem.functions;

const client = new OpenAI();
const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
  { role: 'system', content: 'You have access to a knowledge base. Use the tools to help users.' },
  { role: 'user', content: 'What authentication methods are supported?' },
];

// Function to execute tool calls
async function executeFunction(name: string, args: any): Promise<any> {
  if (name === 'memvid_find') {
    return mem.find(args.query, { k: args.top_k || 5 });
  } else if (name === 'memvid_put') {
    return mem.put({ title: args.title, label: args.label, text: args.text });
  } else if (name === 'memvid_ask') {
    return mem.ask(args.question, { mode: args.mode || 'auto' });
  }
  return null;
}

// Conversation loop
while (true) {
  const response = await client.chat.completions.create({
    model: 'gpt-4o',
    messages,
    tools: functions.map((f: any) => ({ type: 'function' as const, function: f })),
    tool_choice: 'auto',
  });

  const message = response.choices[0].message;
  messages.push(message);

  if (message.tool_calls) {
    for (const toolCall of message.tool_calls) {
      const funcName = toolCall.function.name;
      const funcArgs = JSON.parse(toolCall.function.arguments);
      const result = await executeFunction(funcName, funcArgs);

      messages.push({
        role: 'tool',
        tool_call_id: toolCall.id,
        content: JSON.stringify(result) || 'Function executed',
      });
    }
  } else {
    // No more tool calls, print the response
    console.log(message.content);
    break;
  }
}

from memvid_sdk import use
import openai
import json

mem = use('openai', 'knowledge.mv2')
functions = mem.functions

client = openai.OpenAI()
messages = [
    {"role": "system", "content": "You have access to a knowledge base. Use the tools to help users."},
    {"role": "user", "content": "What authentication methods are supported?"}
]

# Function to execute tool calls
def execute_function(name, args):
    if name == "memvid_find":
        return mem.find(args["query"], k=args.get("top_k", 5))
    elif name == "memvid_put":
        return mem.put(title=args["title"], label=args["label"], text=args["text"])
    elif name == "memvid_ask":
        return mem.ask(args["question"], mode=args.get("mode", "auto"))
    return None

# Conversation loop
while True:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=[{"type": "function", "function": f} for f in functions],
        tool_choice="auto"
    )

    message = response.choices[0].message
    messages.append(message)

    if message.tool_calls:
        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)
            result = execute_function(func_name, func_args)

            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result) if result else "Function executed"
            })
    else:
        # No more tool calls, print the response
        print(message.content)
        break

Function Schemas

memvid_put

{
  "name": "memvid_put",
  "description": "Store a document in Memvid memory for later retrieval",
  "parameters": {
    "type": "object",
    "properties": {
      "title": { "type": "string", "description": "Title of the document" },
      "label": { "type": "string", "description": "Category or label" },
      "text": { "type": "string", "description": "Text content to store" },
      "metadata": { "type": "object", "description": "Optional metadata" }
    },
    "required": ["title", "label", "text"]
  }
}

memvid_find

{
  "name": "memvid_find",
  "description": "Search Memvid memory for documents matching a query",
  "parameters": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Search query string" },
      "top_k": { "type": "number", "description": "Number of results (default: 5)" }
    },
    "required": ["query"]
  }
}

memvid_ask

{
  "name": "memvid_ask",
  "description": "Ask a question and get an answer from Memvid memory",
  "parameters": {
    "type": "object",
    "properties": {
      "question": { "type": "string", "description": "Question to answer" },
      "mode": { "type": "string", "enum": ["auto", "lex", "sem"], "description": "Search mode" }
    },
    "required": ["question"]
  }
}

Best Practices

Use tool_choice=“auto” to let the model decide when to use tools
Handle multiple tool calls - the model may call multiple functions
Complete the loop - continue until no more tool_calls are returned
Close the memory when done

mem = use('openai', 'knowledge.mv2')
try:
    # Use functions...
finally:
    mem.seal()

Frameworks

Installation

Quick Start

Installation

Quick Start

Available Functions

Function Calling Example

Complete Conversation Loop

Function Schemas

memvid_put

memvid_find

memvid_ask

Best Practices

Next Steps

Vercel AI SDK

AutoGen

​Installation

​Quick Start

​Installation

​Quick Start

​Available Functions

​Function Calling Example

​Complete Conversation Loop

​Function Schemas

​memvid_put

​memvid_find

​memvid_ask

​Best Practices

​Next Steps

Vercel AI SDK

AutoGen

Installation

Quick Start

Installation

Quick Start

Available Functions

Function Calling Example

Complete Conversation Loop

Function Schemas

memvid_put

memvid_find

memvid_ask

Best Practices

Next Steps