Google ADK

Integrate Memvid with Google’s Agent Development Kit (ADK) to build Gemini-powered agents with persistent memory. The google-adk adapter provides native ADK function declarations.

Node.js
Python

Installation

npm install @memvid/sdk @google/generative-ai

Quick Start

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

// Open with Google ADK adapter
const mem = await use('google-adk', 'knowledge.mv2');

// Access ADK function declarations
const tools = mem.tools;       // FunctionDeclaration[] for Gemini API
const executors = mem.functions; // Function executors by name

Available Functions

The Google ADK adapter provides three function declarations:

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

Basic Usage with Gemini

import { use } from '@memvid/sdk';
import { GoogleGenerativeAI } from '@google/generative-ai';

// Initialize Memvid with Google ADK adapter
const mem = await use('google-adk', 'knowledge.mv2');

// Get function declarations and executors
const tools = mem.tools as any[];
const executors = mem.functions as Record<string, (args: any) => Promise<string>>;

// Create Gemini client
const geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
if (!geminiKey) throw new Error("Set GEMINI_API_KEY (or legacy GOOGLE_API_KEY)");
const genAI = new GoogleGenerativeAI(geminiKey);

// Create model with Memvid tools
const model = genAI.getGenerativeModel({
  model: 'gemini-2.0-flash',
  tools: [{ functionDeclarations: tools }],
});

// Start a chat
const chat = model.startChat();
const result = await chat.sendMessage('Search for authentication information');

// Handle function calls
const response = result.response;
const parts = response.candidates?.[0]?.content?.parts || [];

for (const part of parts) {
  if (part.functionCall) {
    const { name, args } = part.functionCall;
    console.log(`Function call: ${name}`);

    // Execute the function
    if (executors[name]) {
      const funcResult = await executors[name](args as Record<string, unknown>);
      console.log(`Result: ${funcResult}`);

      // Send result back to model
      const followUp = await chat.sendMessage([{
        functionResponse: {
          name,
          response: { result: funcResult },
        },
      }]);
      console.log(`Model response: ${followUp.response.text()}`);
    }
  } else if (part.text) {
    console.log(`Response: ${part.text}`);
  }
}

Direct Tool Execution

Use the function executors directly without Gemini:

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

const mem = await use('google-adk', 'knowledge.mv2', { mode: 'create' });
const executors = mem.functions as Record<string, (args: any) => Promise<string>>;

// Store documents
const putResult = await executors.memvid_put({
  title: 'API Documentation',
  label: 'docs',
  text: 'Authentication uses JWT tokens with refresh capability.',
});
console.log(putResult);
// Output: Document stored with frame_id: 2

// Search documents
const findResult = await executors.memvid_find({
  query: 'authentication',
  top_k: 5,
});
console.log(findResult);
// Output: Found 1 results:
// 1. [API Documentation] (score: 2.34): Authentication uses JWT tokens...

// Ask questions
const askResult = await executors.memvid_ask({
  question: 'How does authentication work?',
  mode: 'auto',
});
console.log(askResult);
// Output: Answer: Authentication uses JWT tokens with refresh capability.
// Sources: API Documentation

Complete Agentic Example

import { use } from '@memvid/sdk';
import { GoogleGenerativeAI } from '@google/generative-ai';

async function runGeminiAgent() {
  // Initialize
  const mem = await use('google-adk', 'knowledge.mv2');
  const tools = mem.tools as any[];
  const executors = mem.functions as Record<string, (args: any) => Promise<string>>;

  // Store some knowledge first
  await executors.memvid_put({
    title: 'Gemini Overview',
    label: 'google-ai',
    text: 'Gemini is Google\\'s most capable AI model family.',
  });

  await executors.memvid_put({
    title: 'Agent Development Kit',
    label: 'frameworks',
    text: 'ADK is Google\\'s framework for building AI agents.',
  });

  // Create Gemini client
  const geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
  if (!geminiKey) throw new Error("Set GEMINI_API_KEY (or legacy GOOGLE_API_KEY)");
  const genAI = new GoogleGenerativeAI(geminiKey);
  const model = genAI.getGenerativeModel({
    model: 'gemini-2.0-flash',
    tools: [{ functionDeclarations: tools }],
    systemInstruction: 'You are a helpful assistant with access to a knowledge base. ' +
      'Use memvid_find to search and memvid_ask to answer questions.',
  });

  // Run agentic loop
  const chat = model.startChat();

  async function processMessage(userMessage: string): Promise<string> {
    let result = await chat.sendMessage(userMessage);

    // Handle function calls iteratively
    while (true) {
      const parts = result.response.candidates?.[0]?.content?.parts || [];
      const functionCalls = parts.filter((p: any) => p.functionCall);

      if (functionCalls.length === 0) {
        // No more function calls, return text response
        return result.response.text() || 'No response';
      }

      // Execute all function calls
      const responses: any[] = [];
      for (const part of functionCalls) {
        const { name, args } = (part as any).functionCall;
        if (executors[name]) {
          const funcResult = await executors[name](args);
          responses.push({
            functionResponse: { name, response: { result: funcResult } },
          });
        }
      }

      // Send results back
      result = await chat.sendMessage(responses);
    }
  }

  // Example conversation
  const answer = await processMessage(
    'What is Google ADK and how does it relate to Gemini?'
  );
  console.log('Agent response:', answer);

  await mem.seal();
}

runGeminiAgent().catch(console.error);

Installation

pip install memvid-sdk google-genai

Quick Start

from memvid_sdk import use

# Open with Google ADK adapter
mem = use('google-adk', 'knowledge.mv2')

# Access ADK tools
tools = mem.tools  # Returns ADK tool definitions

Basic Usage

from google import genai
from google.genai import types
from memvid_sdk import use

# Initialize with google-adk adapter
mem = use('google-adk', 'knowledge.mv2', read_only=True)

# Get tool definitions
tools = mem.tools

# Create Gemini client
client = genai.Client()

# Create chat with tools
chat = client.chats.create(
    model="gemini-2.0-flash",
    config=types.GenerateContentConfig(
        tools=tools,
        system_instruction="You are a helpful assistant with access to a knowledge base."
    )
)

# Send message
response = chat.send_message("What are the best practices for deployment?")
print(response.text)

Function Calling

from google import genai
from memvid_sdk import use

mem = use('google-adk', 'knowledge.mv2', read_only=True)

# Define tool functions
def memvid_search(query: str) -> str:
    """Search the knowledge base for relevant information."""
    results = mem.find(query, k=5)
    return "\n".join([f"- {r.title}: {r.snippet}" for r in results])

def memvid_ask(question: str) -> str:
    """Ask a question and get an AI-synthesized answer."""
    answer = mem.ask(question)
    return str(answer.get("answer", ""))

# Register functions
tools = [memvid_search, memvid_ask]

# Create client and generate
client = genai.Client()
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="Search for information about authentication",
    config=types.GenerateContentConfig(tools=tools)
)

# Handle function calls
for part in response.candidates[0].content.parts:
    if hasattr(part, 'function_call'):
        fn = part.function_call
        if fn.name == "memvid_search":
            result = memvid_search(fn.args["query"])
            print(result)

Multi-Tool Agent

from google import genai
from google.genai import types
from memvid_sdk import use

mem = use('google-adk', 'knowledge.mv2', read_only=True)

# Define multiple tools
def search_knowledge(query: str) -> str:
    """Search the knowledge base for relevant information."""
    results = mem.find(query, k=5)
    return "\n".join([f"- {r.title}: {r.snippet}" for r in results])

def get_timeline(limit: int = 10) -> str:
    """Get recent entries from the knowledge base."""
    entries = mem.timeline(limit=limit)
    return "\n".join([f"- [{e.timestamp}] {e.title}" for e in entries])

def get_stats() -> str:
    """Get statistics about the knowledge base."""
    stats = mem.stats()
    return f"Documents: {stats['frame_count']}, Size: {stats['size_bytes']} bytes"

def ask_question(question: str) -> str:
    """Ask a question and get an AI-synthesized answer."""
    answer = mem.ask(question)
    return str(answer.get("answer", ""))

# Create client with all tools
client = genai.Client()
chat = client.chats.create(
    model="gemini-2.0-flash",
    config=types.GenerateContentConfig(
        tools=[search_knowledge, get_timeline, get_stats, ask_question],
        system_instruction="You are a helpful assistant with full access to a knowledge base."
    )
)

# Interactive session
response = chat.send_message("Show me recent entries and then search for authentication info")
print(response.text)

Streaming Responses

from google import genai
from memvid_sdk import use

mem = use('google-adk', 'knowledge.mv2', read_only=True)
client = genai.Client()

# Stream response
for chunk in client.models.generate_content_stream(
    model="gemini-2.0-flash",
    contents="Explain the architecture based on the knowledge base",
    config=types.GenerateContentConfig(
        tools=mem.tools,
        system_instruction="You have access to a knowledge base."
    )
):
    print(chunk.text, end="")

Function Declaration Schema

The memvid_put function declaration:

{
  "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 key-value metadata" }
    },
    "required": ["title", "label", "text"]
  }
}

The memvid_find function declaration:

{
  "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"]
  }
}

The memvid_ask function declaration:

{
  "name": "memvid_ask",
  "description": "Ask a question and get an answer from Memvid memory using RAG.",
  "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 read-only mode for retrieval agents
Handle function calls appropriately in responses
Use streaming for long responses
Close the memory when done

Node.js
Python

const mem = await use('google-adk', 'knowledge.mv2', { readOnly: true });
try {
  // Create agent and run queries
  const geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
  if (!geminiKey) throw new Error("Set GEMINI_API_KEY (or legacy GOOGLE_API_KEY)");
  const genAI = new GoogleGenerativeAI(geminiKey);
  // ... use client
} finally {
  // No explicit close needed; dropping the handle releases the shared lock.
}

mem = use('google-adk', 'knowledge.mv2', read_only=True)
try:
    # Create agent and run queries
    client = genai.Client()
    # ... use client
finally:
    mem.close()

Frameworks

Installation

Quick Start

Available Functions

Basic Usage with Gemini

Direct Tool Execution

Complete Agentic Example

Installation

Quick Start

Basic Usage

Function Calling

Multi-Tool Agent

Streaming Responses

Function Declaration Schema

Best Practices

Next Steps

CrewAI

Semantic Kernel

​Installation

​Quick Start

​Available Functions

​Basic Usage with Gemini

​Direct Tool Execution

​Complete Agentic Example

​Installation

​Quick Start

​Basic Usage

​Function Calling

​Multi-Tool Agent

​Streaming Responses

​Function Declaration Schema

​Best Practices

​Next Steps

CrewAI

Semantic Kernel

Installation

Quick Start

Available Functions

Basic Usage with Gemini

Direct Tool Execution

Complete Agentic Example

Installation

Quick Start

Basic Usage

Function Calling

Multi-Tool Agent

Streaming Responses

Function Declaration Schema

Best Practices

Next Steps