Integration: Voyage AI

pip install voyage-embedders-haystack

# Install HuggingFace Datasets using "pip install datasets"
from datasets import load_dataset
from haystack import Pipeline
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.components.writers import DocumentWriter
from haystack.dataclasses import Document
from haystack.document_stores.in_memory import InMemoryDocumentStore

# Import Voyage Embedders
from haystack_integrations.components.embedders.voyage_embedders import VoyageDocumentEmbedder, VoyageTextEmbedder

# Load first 100 rows of the Simple Wikipedia Dataset from HuggingFace
dataset = load_dataset("pszemraj/simple_wikipedia", split="validation[:100]")

docs = [
    Document(
        content=doc["text"],
        meta={
            "title": doc["title"],
            "url": doc["url"],
        },
    )
    for doc in dataset
]

doc_store = InMemoryDocumentStore(embedding_similarity_function="cosine")
retriever = InMemoryEmbeddingRetriever(document_store=doc_store)
doc_writer = DocumentWriter(document_store=doc_store)

doc_embedder = VoyageDocumentEmbedder(
    model="voyage-4",
    input_type="document",
)
text_embedder = VoyageTextEmbedder(model="voyage-4", input_type="query")

# Indexing Pipeline
indexing_pipeline = Pipeline()
indexing_pipeline.add_component(instance=doc_embedder, name="DocEmbedder")
indexing_pipeline.add_component(instance=doc_writer, name="DocWriter")
indexing_pipeline.connect("DocEmbedder", "DocWriter")

indexing_pipeline.run({"DocEmbedder": {"documents": docs}})

print(f"Number of documents in Document Store: {len(doc_store.filter_documents())}")
print(f"First Document: {doc_store.filter_documents()[0]}")
print(f"Embedding of first Document: {doc_store.filter_documents()[0].embedding}")

text_embedder = VoyageTextEmbedder(model="voyage-4", input_type="query")

# Query Pipeline
query_pipeline = Pipeline()
query_pipeline.add_component(instance=text_embedder, name="TextEmbedder")
query_pipeline.add_component(instance=retriever, name="Retriever")
query_pipeline.connect("TextEmbedder.embedding", "Retriever.query_embedding")

# Search
results = query_pipeline.run({"TextEmbedder": {"text": "Which year did the Joker movie release?"}})

# Print text from top result
top_result = results["Retriever"]["documents"][0].content
print("The top search result is:")
print(top_result)

from haystack_integrations.components.rankers.voyage.ranker import VoyageRanker

# Query pipeline: embed -> retrieve -> rerank
rerank_pipeline = Pipeline()
rerank_pipeline.add_component(instance=VoyageTextEmbedder(model="voyage-4", input_type="query"), name="TextEmbedder")
rerank_pipeline.add_component(instance=InMemoryEmbeddingRetriever(document_store=doc_store, top_k=5), name="Retriever")
rerank_pipeline.add_component(instance=VoyageRanker(model="rerank-2.5", top_k=3), name="Ranker")

# Connect embedding -> retriever -> ranker
rerank_pipeline.connect("TextEmbedder.embedding", "Retriever.query_embedding")
rerank_pipeline.connect("Retriever.documents", "Ranker.documents")

# VoyageTextEmbedder does not output `text`, so pass the query to both
# the embedder and the ranker explicitly.
query = "Which year did the Joker movie release?"
results = rerank_pipeline.run({
    "TextEmbedder": {"text": query},
    "Ranker": {"query": query},
})

# Print the top 3 reranked results
for i, doc in enumerate(results["Ranker"]["documents"]):
    print(f"{i + 1}. score={doc.score:.4f} | {doc.content[:120]}")

from haystack import SuperComponent
from haystack.components.agents import Agent
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.dataclasses import ChatMessage
from haystack.tools import ComponentTool

# Expose the retrieve-and-rerank pipeline as a single searchable component.
# input_mapping sends the query to both the embedder and the ranker;
# output_mapping surfaces the reranked documents.
search_component = SuperComponent(
    pipeline=rerank_pipeline,
    input_mapping={"query": ["TextEmbedder.text", "Ranker.query"]},
    output_mapping={"Ranker.documents": "documents"},
)

# Format the retrieved documents into the text the Agent's LLM will read.
def format_documents(documents):
    return "\n\n".join(f"[{i + 1}] {doc.content}" for i, doc in enumerate(documents))

# ComponentTool auto-generates the tool's JSON schema from the component inputs.
search_tool = ComponentTool(
    component=search_component,
    name="voyage_search",
    description="Search the indexed Wikipedia corpus for passages relevant to a query.",
    outputs_to_string={"source": "documents", "handler": format_documents},
)

agent = Agent(
    chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
    tools=[search_tool],
    system_prompt=(
        "You are a helpful assistant. Use the voyage_search tool to find relevant passages "
        "from Wikipedia, then answer the user's question based only on those passages. "
        "If the search results don't contain the answer, say you couldn't find it."
    ),
)

result = agent.run(
    messages=[ChatMessage.from_user("Which year did the Joker movie release?")]
)
print(result["messages"][-1].text)

from haystack import Pipeline
from haystack.components.agents import Agent
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.dataclasses import ChatMessage
from haystack.tools import PipelineTool

# Query pipeline: embed -> retrieve (no reranker)
search_pipeline = Pipeline()
search_pipeline.add_component(instance=VoyageTextEmbedder(model="voyage-4", input_type="query"), name="TextEmbedder")
search_pipeline.add_component(instance=InMemoryEmbeddingRetriever(document_store=doc_store, top_k=3), name="Retriever")
search_pipeline.connect("TextEmbedder.embedding", "Retriever.query_embedding")

# Format the retrieved documents into the text the Agent's LLM will read.
def format_documents(documents):
    return "\n\n".join(f"[{i + 1}] {doc.content}" for i, doc in enumerate(documents))

# PipelineTool wraps the Pipeline directly - no SuperComponent needed.
search_tool = PipelineTool(
    pipeline=search_pipeline,
    input_mapping={"query": ["TextEmbedder.text"]},
    output_mapping={"Retriever.documents": "documents"},
    name="voyage_search",
    description="Search the indexed Wikipedia corpus for passages relevant to a query.",
    outputs_to_string={"source": "documents", "handler": format_documents},
)

agent = Agent(
    chat_generator=OpenAIChatGenerator(model="gpt-4o-mini"),
    tools=[search_tool],
    system_prompt=(
        "You are a helpful assistant. Use the voyage_search tool to find relevant passages "
        "from Wikipedia, then answer the user's question based only on those passages. "
        "If the search results don't contain the answer, say you couldn't find it."
    ),
)

result = agent.run(
    messages=[ChatMessage.from_user("Which year did the Joker movie release?")]
)
print(result["messages"][-1].text)

from haystack import Document
from haystack_integrations.components.embedders.voyage_embedders import VoyageContextualizedDocumentEmbedder

# Create documents with source_id to group related chunks
docs = [
    # Chunks from the same document (source_id: "doc1")
    Document(
        content="Apple Inc. released their Q1 earnings report.",
        meta={"source_id": "doc1", "title": "Apple News"}
    ),
    Document(
        content="Revenue increased by 12% year over year.",
        meta={"source_id": "doc1", "title": "Apple News"}
    ),
    # Chunks from another document (source_id: "doc2")
    Document(
        content="Tesla announced new vehicle production targets.",
        meta={"source_id": "doc2", "title": "Tesla Update"}
    ),
]

# Use VoyageContextualizedDocumentEmbedder for voyage-context-3
embedder = VoyageContextualizedDocumentEmbedder(
    model="voyage-context-3",
    input_type="document",
)

result = embedder.run(documents=docs)

# Chunks with the same source_id are embedded together, preserving context
# This improves retrieval - e.g., searching "Apple revenue growth" will better match
# the second chunk because it maintains its connection to "Apple Inc."

from haystack.dataclasses import ByteStream
from haystack_integrations.components.embedders.voyage_embedders import VoyageMultimodalEmbedder

# Text-only embedding
embedder = VoyageMultimodalEmbedder(model="voyage-multimodal-3.5")
result = embedder.run(inputs=[["A sunset over the ocean"]])
print(f"Embedding dimensions: {len(result['embeddings'][0])}")

# Mixed text and image embedding
image_bytes = ByteStream.from_file_path("image.jpg")
result = embedder.run(inputs=[["Product photo for online store", image_bytes]])
print(f"Tokens used: {result['meta']['total_tokens']}")

from haystack.dataclasses import ByteStream
from haystack_integrations.components.embedders.voyage_embedders import VoyageMultimodalEmbedder

# Configure output dimensions (256, 512, 1024, or 2048)
embedder = VoyageMultimodalEmbedder(
    model="voyage-multimodal-3.5",
    output_dimension=2048,  # Higher dimensions for better accuracy
    input_type="document",  # Optimize for document retrieval
)

# Embed multiple inputs at once
image1 = ByteStream.from_file_path("doc1.jpg")
image2 = ByteStream.from_file_path("doc2.jpg")

result = embedder.run(inputs=[
    ["Document about machine learning", image1],
    ["Technical diagram", image2],
])

print(f"Number of embeddings: {len(result['embeddings'])}")
print(f"Image pixels processed: {result['meta']['image_pixels']}")

from voyageai.video_utils import Video
from haystack_integrations.components.embedders.voyage_embedders import VoyageMultimodalEmbedder

embedder = VoyageMultimodalEmbedder(model="voyage-multimodal-3.5")

# Load video using VoyageAI's Video utility
video = Video.from_path("video.mp4", model="voyage-multimodal-3.5")

# Embed video with optional text context
result = embedder.run(inputs=[["Machine learning tutorial", video]])

print(f"Embedding dimensions: {len(result['embeddings'][0])}")
print(f"Video pixels processed: {result['meta']['video_pixels']}")
print(f"Total tokens: {result['meta']['total_tokens']}")