LlamaIndex 组件 - Models

本文翻译整理自：https://docs.llamaindex.ai/en/stable/module_guides/models/

您可以通过以下几种主要方式与 LlamaIndex 中的模型进行交互：

• LLM
• 嵌入

实验性的

• 多式联运

一、使用LLM

1、概念

在基于数据构建任何 LLM 应用程序时，选择合适的大型语言模型 (LLM) 是您需要考虑的首要步骤之一。

LLM 是 LlamaIndex 的核心组成部分。
它们可以用作 独立模块 或插入其他核心 LlamaIndex 模块（索引、检索器、查询引擎）。
它们总是在响应合成步骤中使用（例如检索后）。
根据所使用的索引类型，LLM 也可以在索引构建、插入和查询遍历期间使用。

LlamaIndex 提供了定义 LLM 模块的统一接口，无论是来自 OpenAI、Hugging Face 还是 LangChain，这样您就不必自己编写定义 LLM 接口的样板代码。
该接口由以下部分组成（更多详细信息如下）：

• 支持文本完成和聊天端点（详细信息如下）
• 支持流式和非流式端点
• 支持同步和异步端点

2、使用模式

以下代码片段展示了如何开始使用LLM 。

如果您还没有，请安装您的 LLM：

pip install llama-index-llms-openai

然后：

from llama_index.llms.openai import OpenAI

# non-streaming
resp = OpenAI().complete("Paul Graham is ")
print(resp)

查找有关独立使用或自定义使用的更多详细信息。

3、关于tokenize 的注释

默认情况下，LlamaIndex 使用全局token器进行所有token计数。
默认为cl100kfrom tiktoken，它是与默认 LLM 匹配的token生成器gpt-3.5-turbo。

如果您更改 LLM，您可能需要更新此分词器以确保准确的分词计数、分块和提示。

分词器的唯一要求是它是一个可调用函数，接受一个字符串并返回一个列表。

您可以像这样设置全局token生成器：

from llama_index.core import Settings

# tiktoken
import tiktoken

Settings.tokenizer = tiktoken.encoding_for_model("gpt-3.5-turbo").encode

# huggingface
from transformers import AutoTokenizer

Settings.tokenizer = AutoTokenizer.from_pretrained(
    "HuggingFaceH4/zephyr-7b-beta"
)

4、LLM 兼容性跟踪

虽然LLM 很强大，但并不是每个LLM 都很容易建立。
此外，即使设置正确，一些LLM 在执行需要严格遵循指令的任务时也遇到困难。

LlamaIndex 提供与几乎所有 LLM 的集成，但通常不清楚 LLM 是否可以很好地开箱即用，或者是否需要进一步定制。

下表尝试验证各种 LlamaIndex 功能对各种LLM 的初步体验。
这些笔记本电脑是衡量性能以及需要付出多少努力和调整才能使其正常运行的最佳尝试。

一般来说，OpenAI 或 Anthropic 等付费 API 被认为更可靠。
然而，本地开源模型由于其可定制性和透明度方法而越来越受欢迎。

**贡献：**欢迎任何人为文档贡献新的LLM 。
只需复制现有笔记本，设置并测试您的LLM ，然后用您的结果打开 PR。

如果您有办法改进现有笔记本的设置，欢迎贡献力量来改变这一点！

Legend

• ✅ = 应该可以正常工作
• ⚠️ = 有时不可靠，可能需要及时的工程改进
• 🛑 = 通常不可靠，需要及时进行工程/微调来改进

4.1 付费 LLM API

4.2 开源LLM

由于开源LLM 需要大量资源，因此报告了量化。
量化只是通过 缩小模型内计算的准确性 来减小 LLM 规模的一种方法。
研究表明，大型 LLM 可以实现高达 4 位的量化，而不会严重影响性能。

5、模块

支持与 OpenAI、Hugging Face、PaLM 等集成。

二、使用LLM 作为独立模块

您可以单独使用 LLM 模块。

1、文本完成示例

from llama_index.llms.openai import OpenAI

# non-streaming
resp = OpenAI().complete("Paul Graham is ")
print(resp)

# using streaming endpoint
from llama_index.llms.openai import OpenAI

llm = OpenAI()
resp = llm.stream_complete("Paul Graham is ")
for delta in resp:
    print(delta, end="")

2、聊天示例

from llama_index.core.llms import ChatMessage
from llama_index.llms.openai import OpenAI

messages = [
    ChatMessage(
        role="system", content="You are a pirate with a colorful personality"
    ),
    ChatMessage(role="user", content="What is your name"),
]
resp = OpenAI().chat(messages)
print(resp)

查看模块部分，了解每个LLM 的使用指南。

三、在 LlamaIndex Abstractions 中自定义 LLM

您可以将这些 LLM 抽象插入到 LlamaIndex 中的其他模块（索引、检索器、查询引擎、代理）中，从而允许您根据数据构建高级工作流程。

默认情况下，我们使用OpenAI的gpt-3.5-turbo模型。
但您可以选择自定义正在使用的底层 LLM。

下面我们展示了一些LLM定制的例子。包括：

• 改变底层的LLM
• 更改输出token的数量（对于 OpenAI、Cohere 或 AI21）
• 对任何 LLM 的所有参数（从上下文窗口到块重叠）进行更细粒度的控制

1、示例：更改基础 LLM

下面显示了自定义所使用的 LLM 的示例片段。
在此示例中，我们使用gpt-4代替gpt-3.5-turbo。

可用模型包括gpt-3.5-turbo、gpt-3.5-turbo-instruct、gpt-3.5-turbo-16k、gpt-4、gpt-4-32k、text-davinci-003和text-davinci-002。

请注意，您还可以插入 Langchain 的 LLM页面上显示的任何 LLM。

from llama_index.core import KeywordTableIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

# alternatively
# from langchain.llms import ...

documents = SimpleDirectoryReader("data").load_data()

# define LLM
llm = OpenAI(temperature=0.1, model="gpt-4")

# build index
index = KeywordTableIndex.from_documents(documents, llm=llm)

# get response from query
query_engine = index.as_query_engine()
response = query_engine.query(
    "What did the author do after his time at Y Combinator?"
)

2、示例：更改输出token的数量（对于 OpenAI、Cohere、AI21）

输出token的数量通常默认设置为某个较低的数字（例如，OpenAI 的默认值为 256）。

对于OpenAI、Cohere、AI21，您只需要设置参数max_tokens（或AI21的maxTokens）。
我们将在幕后处理文本分块/计算。

from llama_index.core import KeywordTableIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
from llama_index.core import Settings

documents = SimpleDirectoryReader("data").load_data()

# define global LLM
Settings.llm = OpenAI(temperature=0, model="gpt-3.5-turbo", max_tokens=512)

3、示例：显式配置context_window和num_output

如果您使用 langchain 中的其他 LLM 类，您可能需要通过Settings 显式配置context_window和num_output ，因为默认情况下该信息不可用。

from llama_index.core import KeywordTableIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
from llama_index.core import Settings

documents = SimpleDirectoryReader("data").load_data()

# set context window
Settings.context_window = 4096
# set number of output tokens
Settings.num_output = 256

# define LLM
Settings.llm = OpenAI(
    temperature=0,
    model="gpt-3.5-turbo",
    max_tokens=num_output,
)

4、示例：使用 HuggingFace LLM

LlamaIndex 支持直接使用 HuggingFace 的 LLM。
请注意，为了获得完全私密的体验，还需要设置本地嵌入模型。

HuggingFace 的许多开源模型在每个提示之前都需要一些序言，即system_prompt。
此外，查询本身可能需要一个额外的包装器query_str。
所有这些信息通常可以从您正在使用的模型的 HuggingFace 模型卡中获得。

下面，此示例同时使用system_prompt和 query_wrapper_prompt，并使用此处找到的模型卡中的特定提示。

from llama_index.core import PromptTemplate

# Transform a string into input zephyr-specific input
def completion_to_prompt(completion):
    return f"<|system|>\n</s>\n<|user|>\n{completion}</s>\n<|assistant|>\n"

# Transform a list of chat messages into zephyr-specific input
def messages_to_prompt(messages):
    prompt = ""
    for message in messages:
        if message.role == "system":
            prompt += f"<|system|>\n{message.content}</s>\n"
        elif message.role == "user":
            prompt += f"<|user|>\n{message.content}</s>\n"
        elif message.role == "assistant":
            prompt += f"<|assistant|>\n{message.content}</s>\n"

    # ensure we start with a system prompt, insert blank if needed
    if not prompt.startswith("<|system|>\n"):
        prompt = "<|system|>\n</s>\n" + prompt

    # add final assistant prompt
    prompt = prompt + "<|assistant|>\n"

    return prompt

import torch
from llama_index.llms.huggingface import HuggingFaceLLM
from llama_index.core import Settings

Settings.llm = HuggingFaceLLM(
    model_name="HuggingFaceH4/zephyr-7b-beta",
    tokenizer_name="HuggingFaceH4/zephyr-7b-beta",
    context_window=3900,
    max_new_tokens=256,
    generate_kwargs={"temperature": 0.7, "top_k": 50, "top_p": 0.95},
    messages_to_prompt=messages_to_prompt,
    completion_to_prompt=completion_to_prompt,
    device_map="auto",
)

如果将分词器中的所有键都传递给模型，某些模型将引发错误。
导致问题的常见分词器输出是token_type_ids。

下面是配置预测器以在将输入传递到模型之前删除此内容的示例：

HuggingFaceLLM(
    # ...
    tokenizer_outputs_to_remove=["token_type_ids"]
)

可以在此处找到完整的 API 参考。

下面还列出了几个示例笔记本：

• StableLM
• LLAMA

5、示例：使用自定义 LLM 模型 - 高级

要使用自定义 LLM 模型，您只需要实现该类LLM（或者CustomLLM更简单的接口），您将负责将文本传递给模型并返回新生成的token。

此实现可以是某种本地模型，甚至可以是您自己的 API 的包装器。

请注意，为了获得完全私密的体验，还需要设置本地嵌入模型。

这是一个小样板示例：

from typing import Optional, List, Mapping, Any

from llama_index.core import SimpleDirectoryReader, SummaryIndex
from llama_index.core.callbacks import CallbackManager
from llama_index.core.llms import (
    CustomLLM,
    CompletionResponse,
    CompletionResponseGen,
    LLMMetadata,
)
from llama_index.core.llms.callbacks import llm_completion_callback
from llama_index.core import Settings

class OurLLM(CustomLLM):
    context_window: int = 3900
    num_output: int = 256
    model_name: str = "custom"
    dummy_response: str = "My response"

    @property
    def metadata(self) -> LLMMetadata:
        """Get LLM metadata."""
        return LLMMetadata(
            context_window=self.context_window,
            num_output=self.num_output,
            model_name=self.model_name,
        )

    @llm_completion_callback()
    def complete(self, prompt: str, **kwargs: Any) -> CompletionResponse:
        return CompletionResponse(text=self.dummy_response)

    @llm_completion_callback()
    def stream_complete(
        self, prompt: str, **kwargs: Any
    ) -> CompletionResponseGen:
        response = ""
        for token in self.dummy_response:
            response += token
            yield CompletionResponse(text=response, delta=token)

# define our LLM
Settings.llm = OurLLM()

# define embed model
Settings.embed_model = "local:BAAI/bge-base-en-v1.5"

# Load the your data
documents = SimpleDirectoryReader("./data").load_data()
index = SummaryIndex.from_documents(documents)

# Query and print response
query_engine = index.as_query_engine()
response = query_engine.query("<query_text>")
print(response)

使用这种方法，您可以使用任何LLM 。
也许您有一个在本地运行，或者在您自己的服务器上运行。
只要实现了该类并返回了生成的token，它就应该可以解决。
请注意，我们需要使用提示助手来自定义提示大小，因为每个模型的上下文长度都略有不同。

装饰器是可选的，但通过 LLM 调用的回调提供可观察性。

请注意，您可能需要调整内部提示才能获得良好的性能。
即使如此，您也应该使用足够大的 LLM，以确保它能够处理 LlamaIndex 内部使用的复杂查询，因此您的情况可能会有所不同。

此处提供了所有默认内部提示的列表，此处列出了特定于聊天的提示。您还可以实现自己的自定义提示。

四、可用的LLM 集成

我们支持与 OpenAI、Anthropic、Hugging Face、PaLM 等集成。

• AI21

• Anthropic

• AnyScale

• Azure OpenAI

• Bedrock

• Clarifai

• Cohere

• Dashscope

• Dashscope Multi-Modal

• EverlyAI

• Fireworks

• Friendli

• Gradient

• Gradient Model Adapter

• Groq

• HuggingFace Camel-7B

• HuggingFace StableLM

• HuggingFace Llama2

• Konko

• LangChain

• LiteLLM

• Llama API

• Llama CPP

• LocalAI

• MariTalk

• MistralAI

• Modelscope

• MonsterAPI

• MyMagic

• NeutrinoAI

• Nvidia TensorRT-LLM

• Nvidia Triton

• Ollama

• OpenAI

• OpenLLM

• OpenRouter

• PaLM

• Perplexity

• PremAI

• Portkey

• Predibase

• Replicate Llama2

• Replicate Vicuna

• Replicate Vector Index Llama2

• RunGPT

• SageMaker

• Solar

• Together.ai

• Vertex

• vLLM

• Xorbits Inference

五、嵌入

1、概念

LlamaIndex 中使用嵌入 来使用 复杂的数字 表示来表示您的文档。
嵌入模型将文本作为输入，并返回一长串用于捕获文本语义的数字。
这些嵌入模型经过训练可以以这种方式表示文本，并有助于实现许多应用程序，包括搜索！

在较高层面上，如果用户询问有关狗的问题，则该问题的嵌入将与谈论狗的文本高度相似。

计算嵌入之间的相似度时，有很多方法可以使用（点积、余弦相似度等）。
默认情况下，LlamaIndex 在比较嵌入时使用余弦相似度。

有许多嵌入模型可供选择。
默认情况下，LlamaIndex 使用text-embedding-ada-002来自 OpenAI 的索引。
我们还支持Langchain提供的任何嵌入模型，并提供一个易于扩展的基类来实现您自己的嵌入。

2、使用模式

最常见的是在 LlamaIndex 中，嵌入模型将在对象中指定Settings，然后在向量索引中使用。
嵌入模型将用于嵌入索引构建过程中使用的文档，以及嵌入稍后使用查询引擎进行的任何查询。
您还可以为每个索引指定嵌入模型。

使用一下代码安装embedding：

pip install llama-index-embeddings-openai

然后：

from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core import Settings

# global
Settings.embed_model = OpenAIEmbedding()

# per-index
index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)

为了节省成本，您可能需要使用本地模型。

pip install llama-index-embeddings-huggingface
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings

Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

这将使用 Hugging Face 中性能良好且快速的默认值。

您可以在下面找到更多使用详细信息和可用的自定义选项。

3、入门

嵌入模型最常见的用法是将其设置在全局Settings对象中，然后使用它来构造索引和查询。
输入文档将被分解为节点，嵌入模型将为每个节点生成一个嵌入。

默认情况下，LlamaIndex 将使用text-embedding-ada-002，这是下面的示例为您手动设置的。

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core import Settings

# global default
Settings.embed_model = OpenAIEmbedding()

documents = SimpleDirectoryReader("./data").load_data()

index = VectorStoreIndex.from_documents(documents)

然后，在查询时，将再次使用嵌入模型来嵌入查询文本。

query_engine = index.as_query_engine()

response = query_engine.query("query string")

4、定制化

4.1 批量大小

默认情况下，嵌入请求以 10 个为一组发送到 OpenAI。
对于某些用户来说，这可能（很少）会产生速率限制。
对于嵌入许多文档的其他用户来说，此批量大小可能太小。

# set the batch size to 42
embed_model = OpenAIEmbedding(embed_batch_size=42)

4.2 局部嵌入模型

使用本地模型的最简单方法是：

from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings

Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

4.3 HuggingFace 最佳 ONNX 嵌入

LlamaIndex 还支持使用 HuggingFace 的 Optimum 库创建和使用 ONNX 嵌入。
简单创建并保存 ONNX 嵌入并使用它们。

一些先决条件：

pip install transformers optimum[exporters]
pip install llama-index-embeddings-huggingface-optimum

指定模型和输出路径的创建：

from llama_index.embeddings.huggingface_optimum import OptimumEmbedding

OptimumEmbedding.create_and_save_optimum_model(
    "BAAI/bge-small-en-v1.5", "./bge_onnx"
)

然后用法：

Settings.embed_model = OptimumEmbedding(folder_name="./bge_onnx")

4.4 Langchain集成

还支持 Langchain提供的任何嵌入。

下面的示例使用 Langchain 的嵌入类从 Hugging Face 加载模型。

pip install llama-index-embeddings-langchain

from langchain.embeddings.huggingface import HuggingFaceBgeEmbeddings
from llama_index.core import Settings

Settings.embed_model = HuggingFaceBgeEmbeddings(model_name="BAAI/bge-base-en")

4.5 自定义嵌入模型

如果您想使用 LlamaIndex 或 Langchain 未提供的嵌入，您还可以扩展我们的基本嵌入类并实现您自己的！

下面的示例使用 Instructor Embeddings（此处安装/设置详细信息），并实现自定义嵌入类。
讲师嵌入通过提供文本以及要嵌入的文本域的“说明”来工作。
当嵌入来自非常具体和专业的主题的文本时，这非常有用。

from typing import Any, List
from InstructorEmbedding import INSTRUCTOR
from llama_index.core.embeddings import BaseEmbedding

class InstructorEmbeddings(BaseEmbedding):
    def __init__(
        self,
        instructor_model_name: str = "hkunlp/instructor-large",
        instruction: str = "Represent the Computer Science documentation or question:",
        **kwargs: Any,
    ) -> None:
        self._model = INSTRUCTOR(instructor_model_name)
        self._instruction = instruction
        super().__init__(**kwargs)

        def _get_query_embedding(self, query: str) -> List[float]:
            embeddings = self._model.encode([[self._instruction, query]])
            return embeddings[0]

        def _get_text_embedding(self, text: str) -> List[float]:
            embeddings = self._model.encode([[self._instruction, text]])
            return embeddings[0]

        def _get_text_embeddings(self, texts: List[str]) -> List[List[float]]:
            embeddings = self._model.encode(
                [[self._instruction, text] for text in texts]
            )
            return embeddings

        async def _get_query_embedding(self, query: str) -> List[float]:
            return self._get_query_embedding(query)

        async def _get_text_embedding(self, text: str) -> List[float]:
            return self._get_text_embedding(text)

5、独立使用

您还可以将嵌入用作项目、现有应用程序或一般测试和探索的独立模块。

embeddings = embed_model.get_text_embedding(
    "It is raining cats and dogs here!"
)

6、支持的嵌入列表

我们支持与 OpenAI、Azure 以及 LangChain 提供的任何产品集成。

• Azure OpenAI
• CalrifAI
• Cohere
• Custom
• Dashscope
• ElasticSearch
• FastEmbed
• Google Palm
• Gradient
• Anyscale
• Huggingface
• JinaAI
• Langchain
• LLM Rails
• MistralAI
• OpenAI
• Sagemaker
• Text Embedding Inference
• TogetherAI
• VoyageAI
• Nomic
• Fireworks AI

六、[Beta] 多模态模型

1、概念

大型语言模型 (LLM) 是文本输入、文本输出的。
大型多模态模型（LMM）将这一点推广到文本模态之外。
例如，GPT-4V 等模型允许您联合输入图像和文本，并输出文本。

我们已经包含了一个基本MultiModalLLM抽象以允许文本+图像模型。
注意：此命名可能会更改！

2、使用模式

1、以下代码片段展示了如何开始使用 LMM，例如 GPT-4V。

from llama_index.multi_modal_llms.openai import OpenAIMultiModal
from llama_index.core.multi_modal_llms.generic_utils import load_image_urls
from llama_index.core import SimpleDirectoryReader

# load image documents from urls
image_documents = load_image_urls(image_urls)

# load image documents from local directory
image_documents = SimpleDirectoryReader(local_directory).load_data()

# non-streaming
openai_mm_llm = OpenAIMultiModal(
    model="gpt-4-vision-preview", api_key=OPENAI_API_TOKEN, max_new_tokens=300
)
response = openai_mm_llm.complete(
    prompt="what is in the image?", image_documents=image_documents
)

2、以下代码片段显示了如何构建多模式向量存储/索引。

from llama_index.core.indices import MultiModalVectorStoreIndex
from llama_index.vector_stores.qdrant import QdrantVectorStore
from llama_index.core import SimpleDirectoryReader, StorageContext

import qdrant_client
from llama_index.core import SimpleDirectoryReader

# Create a local Qdrant vector store
client = qdrant_client.QdrantClient(path="qdrant_mm_db")

# if you only need image_store for image retrieval,
# you can remove text_sotre
text_store = QdrantVectorStore(
    client=client, collection_name="text_collection"
)
image_store = QdrantVectorStore(
    client=client, collection_name="image_collection"
)

storage_context = StorageContext.from_defaults(
    vector_store=text_store, image_store=image_store
)

# Load text and image documents from local folder
documents = SimpleDirectoryReader("./data_folder/").load_data()
# Create the MultiModal index
index = MultiModalVectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
)

3、以下代码片段显示了如何使用多模式检索器和查询引擎。

from llama_index.multi_modal_llms.openai import OpenAIMultiModal
from llama_index.core import PromptTemplate
from llama_index.core.query_engine import SimpleMultiModalQueryEngine

retriever_engine = index.as_retriever(
    similarity_top_k=3, image_similarity_top_k=3
)

# retrieve more information from the GPT4V response
retrieval_results = retriever_engine.retrieve(response)

# if you only need image retrieval without text retrieval
# you can use `text_to_image_retrieve`
# retrieval_results = retriever_engine.text_to_image_retrieve(response)

qa_tmpl_str = (
    "Context information is below.\n"
    "---------------------\n"
    "{context_str}\n"
    "---------------------\n"
    "Given the context information and not prior knowledge, "
    "answer the query.\n"
    "Query: {query_str}\n"
    "Answer: "
)
qa_tmpl = PromptTemplate(qa_tmpl_str)

query_engine = index.as_query_engine(
    multi_modal_llm=openai_mm_llm, text_qa_template=qa_tmpl
)

query_str = "Tell me more about the Porsche"
response = query_engine.query(query_str)

Legend

• ✅ = 应该可以正常工作
• ⚠️ = 有时不可靠，可能需要更多调整来改进
• 🛑 = 目前不可用。

2.1 端到端多模式工作流程

下表尝试展示使用各种 LlamaIndex 功能构建您自己的多模式 RAG（检索增强生成）的初始步骤。
您可以将不同的模块/步骤组合在一起，以组成您自己的多模式 RAG 编排。

2.2 多模式LLM模型

这些笔记本作为如何利用和集成多模态 LLM 模型、多模态嵌入、多模态向量存储、检索器、查询引擎来组成多模态检索增强生成 (RAG) 编排的示例。

2.3 多模态向量存储

下表列出了一些支持多模式用例的矢量存储。
我们的 LlamaIndex 内置MultiModalVectorStoreIndex支持为图像和文本嵌入向量存储构建单独的向量存储。
MultiModalRetriever，并SimpleMultiModalQueryEngine支持文本到文本/图像和图像到图像检索以及用于组合文本和图像检索结果的简单排名融合功能。

3、多模式LLM 模块

我们支持与 GPT4-V、Anthropic（Opus、Sonnet）、Gemini（Google）、CLIP（OpenAI）、BLIP（Salesforce）和 Replicate（LLaVA、Fuyu-8B、MiniGPT-4、CogVLM）等集成。

• OpenAI
• Gemini
• Anthropic
• Replicate
• Pydantic Multi-Modal
• GPT-4v COT Experiments
• Llava Tesla 10q

4、多模态检索增强生成

我们通过具有多模态向量存储的不同多模态 LLM 支持多模态检索增强生成。

• GPT-4v 检索
• 多模态检索
• 图像到图像检索
• Chroma 多模态

5、评估

我们支持多模式LLM 和检索增强生成的基本评估。

• 多模态 RAG 评估

2024-04-15（一）