Integrations Fresh 🌱

Gemini Embedding 2 integrates with major AI frameworks, orchestration tools, and vector databases.

Integration Ecosystem

AI Frameworks

LangChain & LangGraph

from langchain_google_genai import GoogleGenerativeAIEmbeddings

embeddings = GoogleGenerativeAIEmbeddings(
    model='models/gemini-embedding-2-preview',
    task_type='RETRIEVAL_DOCUMENT'
)

# Embed documents
vectors = embeddings.embed_documents([
    'First document text',
    'Second document text',
])

# Embed query
query_vector = embeddings.embed_query('search query')

LlamaIndex

from llama_index.embeddings.google import GoogleGenAIEmbedding

embed_model = GoogleGenAIEmbedding(
    model_name='models/gemini-embedding-2-preview',
    embed_batch_size=100
)

# Use in a VectorStoreIndex
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader('data/').load_data()
index = VectorStoreIndex.from_documents(
    documents,
    embed_model=embed_model
)

query_engine = index.as_query_engine()
response = query_engine.query('What is the main topic?')

CrewAI

from crewai import Agent, Task, Crew
from langchain_google_genai import GoogleGenerativeAIEmbeddings

embeddings = GoogleGenerativeAIEmbeddings(
    model='models/gemini-embedding-2-preview'
)

# Use embeddings in CrewAI knowledge base
# CrewAI agents can leverage these for RAG-based tasks

Vercel AI SDK

import { google } from '@ai-sdk/google';
import { embedMany } from 'ai';

const { embeddings } = await embedMany({
  model: google.textEmbeddingModel('gemini-embedding-2-preview'),
  values: ['First text', 'Second text'],
});

Temporal

Use Temporal for orchestrating embedding pipelines with durable workflows:

from temporalio import workflow, activity

@activity.defn
async def embed_document(doc_text: str) -> list[float]:
    client = genai.Client()
    result = client.models.embed_content(
        model='gemini-embedding-2-preview',
        contents=doc_text,
        config=types.EmbedContentConfig(task_type='RETRIEVAL_DOCUMENT')
    )
    return result.embeddings[0].values

@workflow.defn
class EmbeddingPipeline:
    @workflow.run
    async def run(self, documents: list[str]):
        embeddings = []
        for doc in documents:
            vec = await workflow.execute_activity(
                embed_document, doc,
                start_to_close_timeout=timedelta(seconds=30)
            )
            embeddings.append(vec)
        return embeddings

Vector Databases

ChromaDB

import chromadb
from google import genai
from google.genai import types

client = genai.Client()
chroma = chromadb.PersistentClient(path='./chroma_db')

collection = chroma.get_or_create_collection(
    name='my_collection',
    metadata={'hnsw:space': 'cosine'}
)

# Add documents
text = 'Document content here'
result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=text,
    config=types.EmbedContentConfig(task_type='RETRIEVAL_DOCUMENT')
)

collection.add(
    ids=['doc1'],
    embeddings=[result.embeddings[0].values],
    documents=[text]
)

# Query
query_result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents='search query',
    config=types.EmbedContentConfig(task_type='RETRIEVAL_QUERY')
)

results = collection.query(
    query_embeddings=[query_result.embeddings[0].values],
    n_results=5
)

Qdrant

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct

qdrant = QdrantClient(host='localhost', port=6333)

qdrant.create_collection(
    collection_name='embeddings',
    vectors_config=VectorParams(size=768, distance=Distance.COSINE)
)

# Insert
qdrant.upsert(
    collection_name='embeddings',
    points=[PointStruct(
        id=1,
        vector=embedding_values,
        payload={'text': 'document content', 'type': 'article'}
    )]
)

# Search
hits = qdrant.search(
    collection_name='embeddings',
    query_vector=query_vector,
    limit=10
)

Weaviate

import weaviate

client = weaviate.Client('http://localhost:8080')

# Create class with explicit vectors
client.schema.create_class({
    'class': 'Document',
    'vectorizer': 'none',  # We provide vectors
    'properties': [
        {'name': 'content', 'dataType': ['text']},
        {'name': 'source', 'dataType': ['string']},
    ]
})

# Insert with vector
client.data_object.create(
    data_object={'content': 'Document text', 'source': 'article'},
    class_name='Document',
    vector=embedding_values
)

# Search
result = client.query.get('Document', ['content', 'source']) \
    .with_near_vector({'vector': query_vector}) \
    .with_limit(10) \
    .do()

Pinecone

from pinecone import Pinecone

pc = Pinecone(api_key='YOUR_API_KEY')

index = pc.Index('gemini-embeddings')

# Upsert
index.upsert(vectors=[
    {'id': 'doc1', 'values': embedding_values, 'metadata': {'text': 'content'}},
])

# Query
results = index.query(
    vector=query_vector,
    top_k=10,
    include_metadata=True
)

Google Vector Search (Vertex AI)

from google.cloud import aiplatform

# Create index
index = aiplatform.MatchingEngineIndex.create_tree_ah_index(
    display_name='gemini-embedding-2-index',
    dimensions=768,
    approximate_neighbors_count=50
)

# Deploy to endpoint and query

Integration Decision Tree

See Also

• Getting Started — SDK installation
• RAG Pipeline — End-to-end integration example
• Semantic Search — Search with vector DBs
• API Reference — Direct API usage