Dateisuchtool mit Azure KI-Agent-Dienst

Die Dateisuche erweitert Agents um Kenntnisse, die nicht im Modell enthalten sind, z. B. proprietäre Produktinformationen oder Dokumente, die von Ihren Benutzenden bereitgestellt werden.

Hinweis

Mit dem standardmäßigen Agent-Setup stellt das verbesserte Dateisuchtool sicher, dass Ihre Dateien in Ihrem eigenen Speicher verbleiben, und Ihre Azure KI-Suche-Ressource wird zur Erfassung verwendet, um sicherzustellen, dass Sie die vollständige Kontrolle über Ihre Daten behalten.

Dateiquellen

• Hochladen von lokalen Dateien
• Azure Blob Storage

Unterstützte Verwendung

Azure AI Foundry-Unterstützung	Python SDK	C# SDK	JavaScript SDK	REST-API	Basic Agent-Setup	Standard-Agent-Setup
✔️	✔️	✔️	✔️	✔️	Nur Dateiupload	Hochladen von Dateien und Verwenden von Blob Storage (BYOS)

Abhängigkeit von der Agent-Einrichtung

Grundlegendes Agent-Setup

Das Dateisuchtool verfügt über die gleiche Funktionalität wie Azure OpenAI Assistants. Von Microsoft verwaltete Such- und Speicherressourcen werden verwendet.

• Hochgeladene Dateien werden in von Microsoft verwaltetem Speicher gespeichert.
• Ein Vektorspeicher wird mithilfe einer von Microsoft verwalteten Suchressource erstellt.

Standard-Agent-Setup

Das Dateisuchtool verwendet die Azure KI-Suche- und Azure Blob Storage-Ressourcen, die Sie während der Agent-Einrichtung verbunden haben.

• Hochgeladene Dateien werden in Ihrem verbundenen Azure Blob Storage-Konto gespeichert.
• Vektorspeicher werden mithilfe Ihrer verbundenen Azure KI-Suche-Ressource erstellt.
  
  

Bei beiden Agent-Setups verarbeitet Azure OpenAI den gesamten Erfassungsprozess, der Folgendes umfasst:

• Automatisches Parsen und Aufteilen von Dokumenten
• Generieren und Speichern von Einbettungen
• Verwenden von Vektor- und Schlüsselwortsuchen zum Abrufen relevanter Inhalte für Benutzerabfragen.

Es gibt keinen Unterschied im Code zwischen den beiden Setups. Die einzige Abweichung besteht darin, wo Ihre Dateien und erstellten Vektorspeicher gespeichert werden.

Funktionsweise

Das Dateisuchtool implementiert standardmäßig mehrere bewährte Methoden für den Abruf, um die richtigen Daten aus Ihren Dateien zu extrahieren und die Antworten des Modells zu erweitern. Für das file_search-Tool gilt:

• Schreibt Benutzerabfragen um, um sie für die Suche zu optimieren.
• Unterteilt komplexe Benutzerabfragen in mehrere Suchvorgänge, die parallel ausgeführt werden können.
• Es führt Schlüsselwort- und semantische Suchen sowohl in Agent- als auch in Threadvektorspeichern aus.
• Sortiert Suchergebnisse neu, um die relevantesten auszuwählen, bevor die endgültige Antwort generiert wird.
• Standardmäßig verwendet das Dateisuchtool die folgenden Einstellungen:
  • Blockgröße: 800 Token
  • Blocküberlappung: 400 Token
  • Einbettungsmodell: text-embedding-3-large mit 256 Dimensionen
  • Maximale Anzahl von Blöcken, die dem Kontext hinzugefügt werden: 20

Vektorspeicher

Vektorspeicherobjekte bieten dem Dateisuchtool die Möglichkeit, Ihre Dateien zu durchsuchen. Durch das Hinzufügen einer Datei zu einem Vektorspeicher wird sie automatisch geparst, unterteilt und in eine Vektordatenbank eingebettet, die sowohl für die Schlüsselwortsuche als auch für die semantische Suche geeignet ist. Jeder Vektorspeicher kann bis zu 10.000 Dateien enthalten. Vektorspeicher können an Agents und Threads angefügt werden. Derzeit können Sie höchstens einen Vektorspeicher an einen Agent und höchstens einen an einen Thread anfügen.

Ebenso können diese Dateien aus einem Vektorspeicher entfernt werden. Dazu haben Sie folgende Möglichkeiten:

• Löschen des Vektorspeicherdateiobjekts oder
• Löschen des zugrunde liegenden Dateiobjekts (wodurch die Datei aus allen vector_store- und code_interpreter-Konfigurationen in allen Agents und Threads in Ihrer Organisation entfernt wird)

Die maximale Dateigröße beträgt 512 MB. Jede Datei sollte nicht mehr als 5.000.000 Token pro Datei enthalten (wird automatisch berechnet, wenn Sie eine Datei anfügen).

Sicherstellen der Bereitschaft des Vektorspeichers vor dem Erstellen von Ausführungen

Es wird dringend empfohlen, sicherzustellen, dass alle Dateien in einem vector_store vollständig verarbeitet wurden, bevor Sie eine Ausführung erstellen. Dadurch wird sichergestellt, dass alle Daten in Ihrem Vektorspeicher durchsuchbar sind. Sie können die Bereitschaft des Vektorspeichers überprüfen, indem Sie die Abrufhilfsprogramme in den SDKs verwenden oder das Vektorspeicherobjekt manuell abfragen, um sicherzustellen, dass der Status „abgeschlossen“ ist.

Als Fallback gibt es eine maximale Wartezeit von 60 Sekunden im Ausführungsobjekt, wenn der Vektorspeicher des Threads Dateien enthält, die noch verarbeitet werden. Dadurch wird sichergestellt, dass alle Dateien, die Ihre Benutzer in einen Thread hochladen, vollständig durchsuchbar sind, bevor die Ausführung fortgesetzt wird. Diese Fallbackwartezeit gilt nicht für den Vektorspeicher des Agents.

Hinzufügen der Dateisuche zu einem Agent über das Azure AI Foundry-Portal

Sie können das Bing-Suche-Tool programmgesteuert einem Agent hinzufügen, indem Sie die Codebeispiele verwenden, die oben in diesem Artikel oder im Azure AI Foundry-Portal aufgeführt sind. Wenn Sie das Portal verwenden möchten:

1. Scrollen Sie auf dem Bildschirm Erstellen und debuggen für Ihren Agent im Bereich Setup auf der rechten Seite nach unten bis Wissen. Wählen Sie dann Hinzufügen aus.

   

2. Wählen Sie Dateien aus, und befolgen Sie die Anweisungen, um das Tool hinzuzufügen.

   

   

Schnellstart: Hochladen lokaler Dateien mit Dateisuche

In diesem Beispiel wird mit dem Azure KI-Agent-Dienst ein Agent erstellt, der Ihnen dabei helfen kann, Fragen zu Informationen zu beantworten, die Sie aus lokalen Dateien hochladen.

Voraussetzungen

1. Schließen Sie das Agent-Setup ab.

2. Stellen Sie sicher, dass Sie über die Rolle Mitwirkender an Storage-Blobdaten im Speicherkonto Ihres Projekts verfügen.

3. Stellen Sie sicher, dass Sie über die Rolle Azure KI-Entwickler für Ihr Projekt verfügen.

Schritt 1: Erstellen eines Projektclients

Erstellen Sie ein Clientobjekt, das die Verbindungszeichenfolge zum Herstellen einer Verbindung mit Ihrem KI-Projekt und anderen Ressourcen enthält.

Python

import os
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import FileSearchTool, MessageAttachment, FilePurpose
from azure.identity import DefaultAzureCredential


# Create an Azure AI Client from a connection string, copied from your Azure AI Foundry project.
# At the moment, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<ProjectName>"
# Customer needs to login to Azure subscription via Azure CLI and set the environment variables

credential = DefaultAzureCredential()
project_client = AIProjectClient.from_connection_string(
    credential=credential, conn_str=os.environ["PROJECT_CONNECTION_STRING"] 
)

C#

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Azure.Core.TestFramework;
using NUnit.Framework;

// Create an Azure AI Client from a connection string, copied from your Azure AI Foundry project.
// At the moment, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<ProjectName>"
// Customer needs to login to Azure subscription via Azure CLI and set the environment variables
var connectionString = TestEnvironment.AzureAICONNECTIONSTRING;
AgentsClient client = new AgentsClient(connectionString, new DefaultAzureCredential());

JavaScript

const connectionString =
  process.env["AZURE_AI_PROJECTS_CONNECTION_STRING"] || "<project connection string>";

if (!connectionString) {
  throw new Error("AZURE_AI_PROJECTS_CONNECTION_STRING must be set.");
}
const client = AIProjectsClient.fromConnectionString(
    connectionString || "",
    new DefaultAzureCredential(),
);

REST-API

Legen Sie mithilfe des REST-API-Schnellstarts die richtigen Werte für die Umgebungsvariablen AZURE_AI_AGENTS_TOKEN und AZURE_AI_AGENTS_ENDPOINT fest.

Schritt 2: Hochladen von Dateien und Hinzufügen zu einem Vektorspeicher

Um auf Ihre Dateien zuzugreifen, verwendet das Dateisuchtool das Vektorspeicherobjekt. Laden Sie Ihre Dateien hoch, und erstellen Sie einen Vektorspeicher. Rufen Sie nach dem Erstellen des Vektorspeichers dessen Status ab, bis sich keine Datei mehr im Zustand in_progress befindet. Dadurch wird sichergestellt, dass die Verarbeitung für alle Inhalte läuft. Das SDK stellt Hilfsprogramme zum Hochladen und Abrufen bereit.

Python

# We will upload the local file and will use it for vector store creation.

#upload a file
file = project_client.agents.upload_file_and_poll(file_path='./data/product_catelog.md', purpose=FilePurpose.AGENTS)
print(f"Uploaded file, file ID: {file.id}")

# create a vector store with the file you uploaded
vector_store = project_client.agents.create_vector_store_and_poll(file_ids=[file.id], name="my_vectorstore")
print(f"Created vector store, vector store ID: {vector_store.id}")

C#

// Upload a file and wait for it to be processed
File.WriteAllText(
    path: "sample_file_for_upload.txt",
    contents: "The word 'apple' uses the code 442345, while the word 'banana' uses the code 673457.");
Response<AgentFile> uploadAgentFileResponse = await client.UploadFileAsync(
    filePath: "sample_file_for_upload.txt",
    purpose: AgentFilePurpose.Agents);

AgentFile uploadedAgentFile = uploadAgentFileResponse.Value;

// Create a vector store with the file and wait for it to be processed.
// If you do not specify a vector store, create_message will create a vector store with a default expiration policy of seven days after they were last active
VectorStore vectorStore = await client.CreateVectorStoreAsync(
    fileIds:  new List<string> { uploadedAgentFile.Id },
    name: "my_vector_store");

JavaScript

const localFileStream = fs.createReadStream("sample_file_for_upload.txt");
const file = await client.agents.uploadFile(localFileStream, "assistants", {
  fileName: "sample_file_for_upload.txt",
});
console.log(`Uploaded file, ID: ${file.id}`);

const vectorStore = await client.agents.createVectorStore({
  fileIds: [file.id],
  name: "my_vector_store",
});
console.log(`Created vector store, ID: ${vectorStore.id}`);

REST-API

Hochladen einer Datei

curl $AZURE_AI_AGENTS_ENDPOINT/files?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -F purpose="assistants" \
  -F file="@c:\\path_to_file\\sample_file_for_upload.txt"

Erstellen eines Vektorspeichers

curl $AZURE_AI_AGENTS_ENDPOINT/vector_stores?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my_vector_store"
  }'

Anfügen der hochgeladenen Datei an den Vektorspeicher

curl $AZURE_AI_AGENTS_ENDPOINT/vector_stores/vs_abc123/files?api-version=2024-12-01-preview \
    -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "file_id": "assistant-abc123"
    }'

Schritt 3: Erstellen eines Agents und Aktivieren der Dateisuche

Um die Dateien für Ihren Agent zugänglich zu machen, erstellen Sie ein FileSearchTool-Objekt mit der ID vector_store, und fügen Sie tools und tool_resources an den Agent an.

Python

# create a file search tool
file_search_tool = FileSearchTool(vector_store_ids=[vector_store.id])

# notices that FileSearchTool as tool and tool_resources must be added or the agent will be unable to search the file
agent = project_client.agents.create_agent(
    model="gpt-4o-mini",
    name="my-agent",
    instructions="You are a helpful agent",
    tools=file_search_tool.definitions,
    tool_resources=file_search_tool.resources,
)
print(f"Created agent, agent ID: {agent.id}")

C#

FileSearchToolResource fileSearchToolResource = new FileSearchToolResource();
fileSearchToolResource.VectorStoreIds.Add(vectorStore.Id);

// Create an agent with toolResources and process assistant run
Response<Agent> agentResponse = await client.CreateAgentAsync(
        model: "gpt-4o-mini",
        name: "SDK Test Agent - Retrieval",
        instructions: "You are a helpful agent that can help fetch data from files you know about.",
        tools: new List<ToolDefinition> { new FileSearchToolDefinition() },
        toolResources: new ToolResources() { FileSearch = fileSearchToolResource });
Agent agent = agentResponse.Value;

JavaScript

const fileSearchTool = ToolUtility.createFileSearchTool([vectorStore.id]);

const agent = await client.agents.createAgent("gpt-4o-mini", {
  name: "SDK Test Agent - Retrieval",
  instructions: "You are helpful agent that can help fetch data from files you know about.",
  tools: [fileSearchTool.definition],
  toolResources: fileSearchTool.resources,
});
console.log(`Created agent, agent ID : ${agent.id}`);

REST-API

curl $AZURE_AI_AGENTS_ENDPOINT/assistants?api-version=2024-12-01-preview \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "Financial Analyst Assistant",
    "instructions": "You are an expert financial analyst. Use your knowledge base to answer questions about audited financial statements.",
    "tools": [{"type": "file_search"}],
    "model": "gpt-4o-mini",
    "tool_resources": {"file_search": {"vector_store_ids": ["vs_1234abcd"]}}
  }'

Schritt 4: Erstellen eines Threads

Sie können Dateien auch als Nachrichtenanlagen in Ihrem Thread anfügen. Dadurch wird ein weiterer vector_store erstellt, der dem Thread zugeordnet ist. Wenn bereits ein Vektorspeicher an diesen Thread angefügt ist, werden die neuen Dateien an den vorhandenen Threadvektorspeicher angefügt. Wenn Sie eine Ausführung in diesem Thread erstellen, fragt das Dateisuchtool sowohl den vector_store aus Ihrem Assistenten als auch den vector_store im Thread ab.

Python

# Create a thread
thread = project_client.agents.create_thread()
print(f"Created thread, thread ID: {thread.id}")

# Upload the user provided file as a messsage attachment
message_file = project_client.agents.upload_file_and_poll(file_path='product_info_1.md', purpose=FilePurpose.AGENTS)
print(f"Uploaded file, file ID: {message_file.id}")

# Create a message with the file search attachment
# Notice that vector store is created temporarily when using attachments with a default expiration policy of seven days.
attachment = MessageAttachment(file_id=message_file.id, tools=FileSearchTool().definitions)
message = project_client.agents.create_message(
    thread_id=thread.id, role="user", content="What feature does Smart Eyewear offer?", attachments=[attachment]
)
print(f"Created message, message ID: {message.id}")

C#

// Create thread for communication
Response<AgentThread> threadResponse = await client.CreateThreadAsync();
AgentThread thread = threadResponse.Value;

// Create message to thread
Response<ThreadMessage> messageResponse = await client.CreateMessageAsync(
    thread.Id,
    MessageRole.User,
    "Can you give me the documented codes for 'banana' and 'orange'?");
ThreadMessage message = messageResponse.Value;

JavaScript

// Create thread with file resources.
// If the agent has multiple threads, only this thread can search this file.
const thread = await client.agents.createThread({ toolResources: fileSearchTool.resources });

// add a message to thread
await client.agents.createMessage(
    thread.id, {
    role: "user",
    content: "Can you give me the documented codes for 'banana' and 'orange'?",
});

REST-API

Erstellen eines Threads

curl $AZURE_AI_AGENTS_ENDPOINT/threads?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d ''

Hinzufügen einer Benutzerfrage zum Thread

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/messages?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
      "role": "user",
      "content": "Which months do we have covered in the financial statements?"
    }'

Schritt 5: Erstellen einer Ausführung und Überprüfen der Ausgabe

Wenn Sie eine Ausführung erstellen, können Sie beobachten, dass das Modell das Dateisuchtool verwendet, um eine Antwort auf die Frage der Benutzenden bereitzustellen.

Python

run = project_client.agents.create_and_process_run(thread_id=thread.id, assistant_id=agent.id)
print(f"Created run, run ID: {run.id}")

project_client.agents.delete_vector_store(vector_store.id)
print("Deleted vector store")

project_client.agents.delete_agent(agent.id)
print("Deleted agent")

messages = project_client.agents.list_messages(thread_id=thread.id)
print(f"Messages: {messages}")

C#

// Run the agent
Response<ThreadRun> runResponse = await client.CreateRunAsync(thread, agent);

do
{
    await Task.Delay(TimeSpan.FromMilliseconds(500));
    runResponse = await client.GetRunAsync(thread.Id, runResponse.Value.Id);
}
while (runResponse.Value.Status == RunStatus.Queued
    || runResponse.Value.Status == RunStatus.InProgress);

Response<PageableList<ThreadMessage>> afterRunMessagesResponse
    = await client.GetMessagesAsync(thread.Id);
IReadOnlyList<ThreadMessage> messages = afterRunMessagesResponse.Value.Data;

// Note: messages iterate from newest to oldest, with the messages[0] being the most recent
foreach (ThreadMessage threadMessage in messages)
{
    Console.Write($"{threadMessage.CreatedAt:yyyy-MM-dd HH:mm:ss} - {threadMessage.Role,10}: ");
    foreach (MessageContent contentItem in threadMessage.ContentItems)
    {
        if (contentItem is MessageTextContent textItem)
        {
            Console.Write(textItem.Text);
        }
        else if (contentItem is MessageImageFileContent imageFileItem)
        {
            Console.Write($"<image from ID: {imageFileItem.FileId}");
        }
        Console.WriteLine();
    }
}

JavaScript

  // create a run
  const streamEventMessages = await client.agents.createRun(thread.id, agent.id).stream();

  for await (const eventMessage of streamEventMessages) {
    switch (eventMessage.event) {
      case RunStreamEvent.ThreadRunCreated:
        break;
      case MessageStreamEvent.ThreadMessageDelta:
        {
          const messageDelta = eventMessage.data;
          messageDelta.delta.content.forEach((contentPart) => {
            if (contentPart.type === "text") {
              const textContent = contentPart;
              const textValue = textContent.text?.value || "No text";
            }
          });
        }
        break;

      case RunStreamEvent.ThreadRunCompleted:
        break;
      case ErrorEvent.Error:
        console.log(`An error occurred. Data ${eventMessage.data}`);
        break;
      case DoneEvent.Done:
        break;
    }
  }

  // Print the messages from the agent
  const messages = await client.agents.listMessages(thread.id);

  // Messages iterate from oldest to newest
  // messages[0] is the most recent
  for (let i = messages.data.length - 1; i >= 0; i--) {
    const m = messages.data[i];
    if (isOutputOfType<MessageTextContentOutput>(m.content[0], "text")) {
      const textContent = m.content[0];
      console.log(`${textContent.text.value}`);
      console.log(`---------------------------------`);
    }
  }

REST-API

Ausführen des Threads

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/runs?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "assistant_id": "asst_abc123",
  }'

Abrufen des Ausführungsstatus

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/runs/run_abc123?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN"

Abrufen der Agent-Antwort

curl $AZURE_AI_AGENTS_ENDPOINT/threads/thread_abc123/messages?api-version=2024-12-01-preview \
  -H "Authorization: Bearer $AZURE_AI_AGENTS_TOKEN"

Schnellstart: Verwenden vorhandener Dateien in Azure Blob Storage mit der Dateisuche

In diesem Beispiel wird mit dem Azure KI-Agent-Dienst ein Agent erstellt, der Ihnen dabei helfen kann, Fragen zu Informationen aus Dateien in Azure Blob Storage zu beantworten.

Voraussetzungen

1. Schließen Sie das Standard-Agent-Setup ab.

2. Stellen Sie sicher, dass Sie über die Rolle Mitwirkender an Storage-Blobdaten im Speicherkonto Ihres Projekts verfügen.

3. Stellen Sie sicher, dass Sie über die Rolle Azure KI-Entwickler für Ihr Projekt verfügen.

Wichtig

Die Dateisuche mit Blob Storage wird nur von der standardmäßigen Agent-Einrichtung unterstützt.

Schritt 1: Erstellen eines Projektclients

import os
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import FileSearchTool, VectorStoreDataSource, VectorStoreDataSourceAssetType
from azure.identity import DefaultAzureCredential


# Create an Azure AI Client from a connection string, copied from your Azure AI Foundry project.
# At the moment, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<ProjectName>"
# Customer needs to login to Azure subscription via Azure CLI and set the environment variables

credential = DefaultAzureCredential()
project_client = AIProjectClient.from_connection_string(
    credential=credential, conn_str=os.environ["PROJECT_CONNECTION_STRING"]
)

Schritt 2: Hochladen lokaler Dateien in den Azure Blob Storage-Container des Projekts

Laden Sie Ihre lokale Datei in den Azure Blob Storage-Container des Projekts hoch. Dies ist dasselbe Speicherkonto, das Sie während des Setups mit Ihrem Agent verbunden haben. Beim Erstellen zusätzlicher Agents innerhalb desselben Projekts können Sie die Ressourcen-URIs aller zuvor hochgeladenen Dateien, die diese Agents benötigen, wiederverwenden. Dies bedeutet, dass Sie dieselbe Datei nicht wiederholt hochladen müssen, da die Ressourcen-URIs es Ihnen ermöglichen, direkt auf die Dateien zu verweisen.

Erstellen Sie dann mithilfe des asset_uri einen Vektorspeicher als Speicherort Ihrer Datei im Datenspeicher Ihres Projekts.

# We'll upload the local file to your project Azure Blob Storage container and will use it for vector store creation.
_, asset_uri = project_client.upload_file("sample_file_for_upload.md")
print(f"Uploaded file, asset URI: {asset_uri}")

# create a vector store with a file in blob storage and wait for it to be processed
ds = VectorStoreDataSource(asset_identifier=asset_uri, asset_type=VectorStoreDataSourceAssetType.URI_ASSET)
vector_store = project_client.agents.create_vector_store_and_poll(data_sources=[ds], name="sample_vector_store")
print(f"Created vector store, vector store ID: {vector_store.id}")

Schritt 3: Erstellen eines Agents mit Zugriff auf das Dateisuchtool

# create a file search tool
file_search_tool = FileSearchTool(vector_store_ids=[vector_store.id])

# notices that FileSearchTool as tool and tool_resources must be added or the assistant unable to search the file
agent_1 = project_client.agents.create_agent(
    model="gpt-4o-mini",
    name="my-assistant",
    instructions="You are helpful assistant",
    tools=file_search_tool.definitions,
    tool_resources=file_search_tool.resources,
)
# [END upload_file_and_create_agent_with_file_search]
print(f"Created agent_1, agent_1 ID: {agent_1.id}")

thread = project_client.agents.create_thread()
print(f"Created thread, thread ID: {thread.id}")

message = project_client.agents.create_message(
    thread_id=thread.id, role="user", content="What feature does Smart Eyewear offer?"
)
print(f"Created message, message ID: {message.id}")

run = project_client.agents.create_and_process_run(thread_id=thread.id, assistant_id=agent_1.id)

project_client.agents.delete_vector_store(vector_store.id)
print("Deleted vector store")

project_client.agents.delete_agent(agent.id)
print("Deleted agent")

messages = project_client.agents.list_messages(thread_id=thread.id)
print(f"Messages: {messages}")

Schritt 4: Erstellen eines zweiten Vektorspeichers mithilfe der zuvor hochgeladenen Datei

Erstellen Sie nun einen zweiten Vektorspeicher mithilfe der zuvor hochgeladenen Datei. Die Verwendung des asset_uri einer Datei, die sich bereits in Azure Blob Storage befindet, ist nützlich, wenn Sie über mehrere Agents verfügen, die Zugriff auf dieselben Dateien benötigen, da dabei die Notwendigkeit zum mehrfachen Hochladen derselben Datei entfällt.

# create a vector store with a previously uploaded file and wait for it to be processed
ds_2 = VectorStoreDataSource(asset_identifier=asset_uri, asset_type=VectorStoreDataSourceAssetType.URI_ASSET)
vector_store_2 = project_client.agents.create_vector_store_and_poll(data_sources=[ds_2], name="sample_vector_store_2")
print(f"Created vector store, vector store ID: {vector_store.id}")

Schritt 5: Erstellen eines zweiten Agents mit Zugriff auf das Dateisuchtool

file_search_tool_2 = FileSearchTool(vector_store_ids=[vector_store_2.id])
# notices that FileSearchTool as tool and tool_resources must be added or the assistant unable to search the file
agent_2 = project_client.agents.create_agent(
    model="gpt-4o-mini",
    name="my-assistant-2",
    instructions="You are helpful assistant",
    tools=file_search_tool_2.definitions,
    tool_resources=file_search_tool_2.resources,
)
# [END upload_file_and_create_agent_with_file_search]
print(f"Created agent, agent ID: {agent_2.id}")

Unterstützte Dateitypen

Hinweis

Bei Text-/MIME-Typen muss die Codierung entweder utf-8, utf-16 oder ASCII sein.

Dateiformat	MIME-Typ
.c	text/x-c
.cs	text/x-csharp
.cpp	text/x-c++
.doc	application/msword
.docx	application/vnd.openxmlformats-officedocument.wordprocessingml.document
.html	text/html
.java	text/x-java
.json	application/json
.md	text/markdown
.pdf	application/pdf
.php	text/x-php
.pptx	application/vnd.openxmlformats-officedocument.presentationml.presentation
.py	text/x-python
.py	text/x-script.python
.rb	text/x-ruby
.tex	text/x-tex
.txt	text/plain
.css	text/css
.js	text/javascript
.sh	application/x-sh
.ts	application/typescript

Erstellen von Vektorspeichern und Hinzufügen von Dateien

Das Hinzufügen von Dateien zu Vektorspeichern ist ein asynchroner Vorgang. Um sicherzustellen, dass der Vorgang abgeschlossen ist, empfehlen wir Ihnen, die Hilfsprogramme „Erstellen und Abfragen“ in unseren offiziellen SDKs zu verwenden. Wenn Sie die SDKs nicht verwenden, können Sie das vector_store-Objekt abrufen und dessen file_counts-Eigenschaft überwachen, um das Ergebnis des Dateierfassungsvorgangs anzuzeigen.

Dateien können auch zu einem Vektorspeicher hinzugefügt werden, nachdem er erstellt wurde, indem Sie Vektorspeicherdateien erstellen.

# create a vector store with no file and wait for it to be processed
vector_store = project_client.agents.create_vector_store_and_poll(data_sources=[], name="sample_vector_store")
print(f"Created vector store, vector store ID: {vector_store.id}")

# add the file to the vector store or you can supply file ids in the vector store creation
vector_store_file_batch = project_client.agents.create_vector_store_file_batch_and_poll(
    vector_store_id=vector_store.id, file_ids=[file.id]
)
print(f"Created vector store file batch, vector store file batch ID: {vector_store_file_batch.id}")

Alternativ können Sie einem Vektorspeicher mehrere Dateien hinzufügen, indem Sie Batches mit bis zu 500 Dateien erstellen.

batch = project_client.agents.create_vector_store_file_batch_and_poll(
  vector_store_id=vector_store.id,
  file_ids=[file_1.id, file_2.id, file_3.id, file_4.id, file_5.id]
)

Grundlegendes Agent-Setup: Löschen von Dateien aus Vektorspeichern

Dateien können aus einem Vektorspeicher entfernt werden. Dazu haben Sie folgende Möglichkeiten:

• Löschen des Vektorspeicherdateiobjekts oder
• Löschen des zugrunde liegenden Dateiobjekts (wodurch die Datei aus allen vector_store- und code_interpreter-Konfigurationen in allen Assistenten und Threads in Ihrer Organisation entfernt wird)

Die maximale Dateigröße beträgt 512 MB. Jede Datei sollte nicht mehr als 5.000.000 Token pro Datei enthalten (wird automatisch berechnet, wenn Sie eine Datei anfügen).

Entfernen des Vektorspeichers

Sie können einen Vektorspeicher aus dem Dateisuchtool entfernen.

file_search_tool.remove_vector_store(vector_store.id)
print(f"Removed vector store from file search, vector store ID: {vector_store.id}")

project_client.agents.update_agent(
    assistant_id=agent.id, tools=file_search_tool.definitions, tool_resources=file_search_tool.resources
)
print(f"Updated agent, agent ID: {agent.id}")

Löschen von Vektorspeichern

project_client.agents.delete_vector_store(vector_store.id)
print("Deleted vector store")

Verwalten von Kosten mit Ablaufrichtlinien

Für das grundlegende Agent-Setup verwendet das file_search-Tool das vector_stores-Objekt als Ressource, und die Abrechnung erfolgt basierend auf der Größe der erstellten vector_store-Objekte. Die Größe des Vektorspeicherobjekts ist die Summe aller geparsten Blöcke aus Ihren Dateien und der entsprechenden Einbettungen.

Um Ihnen bei der Verwaltung der Kosten für diese vector_store-Objekte zu helfen, haben wir Unterstützung für Ablaufrichtlinien im vector_store-Objekt hinzugefügt. Sie können diese Richtlinien beim Erstellen oder Aktualisieren des vector_store-Objekts festlegen.

vector_store = project_client.agents.create_vector_store_and_poll(
  name="Product Documentation",
  file_ids=[file_1.id],
  expires_after={
      "anchor": "last_active_at",
      "days": 7
  }
)

Standardablaufrichtlinien für Threadvektorspeicher

Vektorspeicher, die mithilfe von Threadhilfsprogrammen (wie tool_resources.file_search.vector_stores in Threads oder message.attachments in Nachrichten) erstellt wurden, haben eine Standardablaufrichtlinie von sieben Tagen nach der letzten Aktivität (definiert als der Zeitpunkt, an dem der Vektorspeicher das letzte Mal Teil einer Ausführung war).

Wenn ein Vektorspeicher abläuft, treten bei Ausführungen in diesem Thread Fehler auf. Um dieses Problem zu beheben, können Sie einen neuen vector_store mit denselben Dateien neu erstellen und an den Thread anfügen.