ollama doc embedder available?

[iplayfast]

I'm trying out a simple program and substituting OllamaGenerator for the HuggingFaceLocalGenerator. Ran into problems with the Doc Embedder as it is running the haystack version. What is the Ollama equivielent of

SentenceTransformersDocumentEmbedder(model_name_or_path="thenlper/gte-large", device="cuda:0", meta_fields_to_embed=["title"]))

Full code is:

from pprint import pprint
import torch
import rich
import random
import wikipedia
from haystack.dataclasses import Document
from haystack.components.generators import HuggingFaceLocalGenerator
from haystack.components.builders import PromptBuilder
from haystack.components.retrievers import InMemoryEmbeddingRetriever
from ollama_haystack import OllamaGenerator
# Retrieve Wikipedia Pages

favourite_artists="""Britney Spears
Ricky Martin
Madonna
Justin Timberlake
Christina Aguilera
Jennifer Lopez
Shakira
Enrique Iglesias
Mariah Carey
Beyoncé""".split("\n")

raw_docs=[]

for title in favourite_artists:
    page = wikipedia.page(title=title, auto_suggest=False)
    doc = Document(content=page.content, meta={"title": page.title, "url":page.url})
    raw_docs.append(doc)

# Indexing Pipeline

from haystack import Pipeline
from haystack.document_stores import InMemoryDocumentStore
from haystack.components.preprocessors import DocumentCleaner, DocumentSplitter
from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
from haystack.components.writers import DocumentWriter
from haystack.components.writers.document_writer import DuplicatePolicy

document_store = InMemoryDocumentStore(embedding_similarity_function="cosine")

indexing = Pipeline()
indexing.add_component("cleaner", DocumentCleaner())
indexing.add_component("splitter", DocumentSplitter(split_by='sentence', split_length=2))
indexing.add_component("doc_embedder", SentenceTransformersDocumentEmbedder(model_name_or_path="thenlper/gte-large", device="cuda:0", meta_fields_to_embed=["title"]))
indexing.add_component("writer", DocumentWriter(document_store=document_store, policy=DuplicatePolicy.OVERWRITE))

indexing.connect("cleaner", "splitter")
indexing.connect("splitter", "doc_embedder")
indexing.connect("doc_embedder", "writer")

indexing.draw("indexing.png")
indexing.run({"cleaner":{"documents":raw_docs}})

# print(len(document_store.filter_documents()))
# pprint(document_store.filter_documents()[0].meta)
# pprint(document_store.filter_documents()[0])
# print(len(document_store.filter_documents()[0].embedding)) # embedding size

"""generator = HuggingFaceLocalGenerator("HuggingFaceH4/zephyr-7b-beta",
            huggingface_pipeline_kwargs={"device_map":"auto",
                          "model_kwargs":{"load_in_4bit":True,
                          "bnb_4bit_use_double_quant":True,
                          "bnb_4bit_quant_type":"nf4",
                          "bnb_4bit_compute_dtype":torch.bfloat16}},
            generation_kwargs={"max_new_tokens": 350})
"""
generator = OllamaGenerator(model="mistral",url="http://localhost:11434/api/generate")


prompt_template = """<|system|>Using the information contained in the context, give a comprehensive answer to the question.
If the answer is contained in the context, also report the source URL.
If the answer cannot be deduced from the context, do not give an answer.</s>
<|user|>
Context:
  {% for doc in documents %}
  {{ doc.content }} URL:{{ doc.meta['url'] }}
  {% endfor %};
  Question: {{query}}
  </s>
<|assistant|>
"""
prompt_builder = PromptBuilder(template=prompt_template)

rag = Pipeline()
rag.add_component("text_embedder", SentenceTransformersTextEmbedder(model_name_or_path="thenlper/gte-large", device="cuda:0"))
rag.add_component("retriever", InMemoryEmbeddingRetriever(document_store=document_store, top_k=5))
rag.add_component("prompt_builder", prompt_builder)
rag.add_component("llm", generator)

rag.connect("text_embedder", "retriever")
rag.connect("retriever.documents", "prompt_builder.documents")
rag.connect("prompt_builder.prompt", "llm.prompt")

rag.draw("rag.png")

def get_generative_answer(query):
  results = rag.run({
      "text_embedder": {"text": query},
      "prompt_builder": {"query": query}
    }
  )
  answer = results["llm"]["replies"][0]
  rich.print(answer)

# Ask Question
get_generative_answer("What are some of Jennifer Lopez's most successful singles?")

[anakin87]

Currently, the Ollama integration only supports Generators (LLMs) and not Embedders.
I opened an issue for that: deepset-ai/haystack-core-integrations#190