Narzędzie wyszukiwania plików usługi agenta sztucznej inteligencji platformy Azure

Wyszukiwanie plików rozszerza agentów o wiedzę spoza swojego modelu, na przykład informacje o zastrzeżonym produkcie lub dokumenty udostępniane przez użytkowników.

Źródła plików

• Przekazywanie plików lokalnych
• Azure Blob Storage

Obsługa użycia

Zależność od konfiguracji agenta

Konfiguracja agenta podstawowego

Narzędzie do wyszukiwania plików ma taką samą funkcjonalność, jak asystenci usługi Azure OpenAI. Używane są zasoby usługi wyszukiwania i magazynowania zarządzane przez firmę Microsoft.

• Przekazane pliki są przechowywane w magazynie zarządzanym przez firmę Microsoft
• Magazyn wektorów jest tworzony przy użyciu zasobu wyszukiwania zarządzanego przez firmę Microsoft

Konfiguracja agenta standardowego

Narzędzie do wyszukiwania plików korzysta z zasobów usługi Azure AI Search i Azure Blob Storage połączonych podczas konfigurowania agenta.

• Przekazane pliki są przechowywane na połączonym koncie usługi Azure Blob Storage
• Magazyny wektorowe są tworzone przy użyciu połączonego zasobu usługi Azure AI Search
  
  

W przypadku obu konfiguracji agentów usługa Azure OpenAI obsługuje cały proces pozyskiwania, który obejmuje:

• Automatyczne analizowanie i dzielenie dokumentów
• Generowanie i przechowywanie osadzonych
• Użycie wyszukiwania wektorów i słów kluczowych w celu pobrania odpowiedniej zawartości dla zapytań użytkowników.

Nie ma różnicy w kodzie między dwiema konfiguracjami; jedyną odmianą jest miejsce przechowywania plików i utworzonych magazynów wektorów.

Jak to działa

Narzędzie do wyszukiwania plików implementuje kilka najlepszych rozwiązań dotyczących pobierania, które ułatwiają wyodrębnianie odpowiednich danych z plików i rozszerzanie odpowiedzi modelu. Narzędzie wyszukiwania plików:

• Ponownie zapisuje zapytania użytkowników, aby zoptymalizować je pod kątem wyszukiwania.
• Dzieli złożone zapytania użytkowników na wiele wyszukiwań, które mogą być uruchamiane równolegle.
• Uruchamia zarówno słowa kluczowe, jak i semantyczne wyszukiwania zarówno w magazynach wektorów agenta, jak i wątku.
• Ponownie pobiera wyniki wyszukiwania, aby wybrać najbardziej odpowiednie przed wygenerowaniem ostatecznej odpowiedzi.
• Domyślnie narzędzie do wyszukiwania plików używa następujących ustawień:
  • Rozmiar fragmentu: 800 tokenów
  • Nakładanie się fragmentów: 400 tokenów
  • Model osadzania: osadzanie tekstu -3-duże przy wymiarach 256
  • Maksymalna liczba fragmentów dodanych do kontekstu: 20

Magazyny wektorów

Obiekty magazynu wektorowego zapewniają narzędziu wyszukiwania plików możliwość przeszukiwania plików. Dodanie pliku do magazynu wektorów automatycznie analizuje, fragmenty, osadza i przechowuje plik w bazie danych wektorów, która jest w stanie wyszukiwać zarówno słowa kluczowego, jak i semantycznego. Każdy magazyn wektorów może zawierać maksymalnie 10 000 plików. Magazyny wektorowe można dołączać zarówno do agentów, jak i wątków. Obecnie można dołączyć co najwyżej jeden magazyn wektorów do agenta i co najwyżej jeden magazyn wektorów do wątku.

Podobnie te pliki można usunąć z magazynu wektorów za pomocą jednego z następujących elementów:

• Usuwanie obiektu pliku magazynu wektorów lub,
• Usuwając obiekt pliku źródłowego, który usuwa go ze wszystkich vector_store i code_interpreter konfiguracji dla wszystkich agentów i wątków w organizacji

Maksymalny rozmiar pliku to 512 MB. Każdy plik powinien zawierać nie więcej niż 5 000 000 tokenów (obliczane automatycznie podczas dołączania pliku).

Zapewnianie gotowości magazynu wektorów przed utworzeniem przebiegów

Zdecydowanie zalecamy upewnienie się, że wszystkie pliki w vector_store są w pełni przetwarzane przed utworzeniem przebiegu. Dzięki temu wszystkie dane w magazynie wektorów można przeszukiwać. Możesz sprawdzić gotowość magazynu wektorów przy użyciu pomocników sondowania w zestawach SDK lub ręcznie sondując obiekt magazynu wektorów, aby upewnić się, że stan został ukończony.

Jako rezerwowy maksymalny czas oczekiwania w obiekcie uruchamiania wynosi 60 sekund, gdy magazyn wektorów wątku zawiera pliki, które są nadal przetwarzane. Ma to na celu zapewnienie, że wszystkie pliki przekazywane przez użytkowników w wątku będą w pełni możliwe do przeszukiwania przed kontynuowaniem przebiegu. To oczekiwanie rezerwowe nie ma zastosowania do magazynu wektorów agenta.

Dodawanie wyszukiwania plików do agenta przy użyciu portalu azure AI Foundry

Narzędzie wyszukiwania Bing można dodać do agenta programowo przy użyciu przykładów kodu wymienionych w górnej części tego artykułu lub portalu usługi Azure AI Foundry. Jeśli chcesz użyć portalu:

1. Na ekranie Tworzenie i debugowanie agenta przewiń w dół okienko Konfiguracja po prawej stronie, aby uzyskać wiedzę. Następnie wybierz pozycję Dodaj.

   

2. Wybierz pozycję Pliki i postępuj zgodnie z monitami, aby dodać narzędzie.

   

   

Szybki start — przekazywanie plików lokalnych za pomocą wyszukiwania plików

W tym przykładzie używamy usługi Azure AI Agent Service do utworzenia agenta, który może pomóc w odpowiadaniu na pytania dotyczące informacji przekazywanych z plików lokalnych.

Wymagania wstępne

1. Ukończ konfigurację agenta.

2. Upewnij się, że masz rolę Współautor danych obiektu blob usługi Storage na koncie magazynu projektu.

3. Upewnij się, że masz rolę Deweloper sztucznej inteligencji platformy Azure w projekcie.

Krok 1. Tworzenie klienta projektu

Utwórz obiekt klienta zawierający parametry połączenia na potrzeby nawiązywania połączenia z projektem sztucznej inteligencji i innymi zasobami.

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"] 
)

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());

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(),
);

Krok 2. Przekazywanie plików i dodawanie ich do magazynu wektorów

Aby uzyskać dostęp do plików, narzędzie wyszukiwania plików używa obiektu magazynu wektorów. Przekaż pliki i utwórz magazyn wektorów. Po utworzeniu magazynu wektorów sonduj jego stan, aż wszystkie pliki nie będą w in_progress stanie, aby upewnić się, że cała zawartość jest w pełni przetwarzana. Zestaw SDK udostępnia pomocników do przekazywania i sondowania.

# 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}")

// 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");

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}`);

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"

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"
  }'

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"
    }'

Krok 3. Tworzenie agenta i włączanie wyszukiwania plików

Aby pliki były dostępne dla agenta, utwórz FileSearchTool obiekt o identyfikatorze vector_store i dołącz tools go tool_resources do agenta.

# 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}")

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;

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}`);

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"]}}
  }'

Krok 4. Tworzenie wątku

Możesz również dołączyć pliki jako załączniki wiadomości w wątku. Spowoduje to utworzenie innego vector_store skojarzonego z wątkiem lub, jeśli istnieje już magazyn wektorów dołączony do tego wątku, dołącza nowe pliki do istniejącego magazynu wektorów wątków. Podczas tworzenia przebiegu w tym wątku narzędzie wyszukiwania plików wysyła zapytania zarówno vector_store z agenta, jak vector_store i do wątku.

# 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}")

// 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;

// 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'?",
});

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 ''

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?"
    }'

Krok 5. Tworzenie przebiegu i sprawdzanie danych wyjściowych

Utwórz przebieg i zwróć uwagę, że model używa narzędzia wyszukiwania plików w celu dostarczenia odpowiedzi na pytanie użytkownika.

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}")

// 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();
    }
}

  // 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(`---------------------------------`);
    }
  }

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",
  }'

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

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

Szybki start — używanie istniejących plików w usłudze Azure Blob Storage z wyszukiwaniem plików

W tym przykładzie używamy usługi Azure AI Agent Service do utworzenia agenta, który może pomóc w odpowiadaniu na pytania dotyczące informacji z plików w usłudze Azure Blob Storage.

Wymagania wstępne

1. Ukończ konfigurację agenta standardowego.

2. Upewnij się, że masz rolę Współautor danych obiektu blob usługi Storage na koncie magazynu projektu.

3. Upewnij się, że masz rolę Deweloper sztucznej inteligencji platformy Azure w projekcie.

Krok 1. Tworzenie klienta projektu

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"]
)

Krok 2. Przekazywanie plików lokalnych do kontenera usługi Azure Blob Storage projektu

Przekaż plik lokalny do kontenera usługi Azure Blob Storage projektu. Jest to to samo konto magazynu, które zostało połączone z agentem podczas instalacji. Podczas tworzenia dodatkowych agentów w tym samym projekcie można ponownie użyć identyfikatorów URI zasobów wszystkich wcześniej przekazanych plików, których potrzebują ci agenci. Oznacza to, że nie trzeba wielokrotnie przekazywać tego samego pliku, ponieważ identyfikatory URI zasobów umożliwiają bezpośrednie odwoływanie się do plików.

Następnie utwórz magazyn wektorów przy użyciu asset_uriobiektu , który jest lokalizacją pliku w magazynie danych projektu.

# 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}")

Krok 3. Tworzenie agenta z dostępem do narzędzia wyszukiwania plików

# 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}")

Krok 4. Tworzenie drugiego magazynu wektorów przy użyciu wcześniej przekazanego pliku

Teraz utwórz drugi magazyn wektorów przy użyciu wcześniej przekazanego pliku. asset_uri Użycie pliku już w usłudze Azure Blob Storage jest przydatne, jeśli masz wielu agentów, którzy potrzebują dostępu do tych samych plików, co eliminuje konieczność wielokrotnego przekazywania tego samego pliku.

# 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}")

Krok 5. Tworzenie drugiego agenta z dostępem do narzędzia wyszukiwania plików

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}")

Typy obsługiwanych plików

Tworzenie magazynów wektorów i dodawanie plików

Dodawanie plików do magazynów wektorów jest operacją asynchroniową. Aby upewnić się, że operacja została ukończona, zalecamy użycie pomocników "create and poll" w naszych oficjalnych zestawach SDK. Jeśli nie używasz zestawów SDK, możesz pobrać vector_store obiekt i monitorować jego file_counts właściwość, aby zobaczyć wynik operacji pozyskiwania pliku.

Pliki można również dodawać do magazynu wektorów po jego utworzeniu, tworząc pliki magazynu wektorów.

# 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}")

Alternatywnie można dodać kilka plików do magazynu wektorów, tworząc partie maksymalnie 500 plików.

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]
)

Podstawowa konfiguracja agenta: usuwanie plików z magazynów wektorów

Pliki można usunąć z magazynu wektorów za pomocą jednego z następujących elementów:

• Usuwanie obiektu pliku magazynu wektorów lub,
• Usunięcie obiektu pliku źródłowego, który usuwa go ze wszystkich vector_store i code_interpreter konfiguracji we wszystkich agentach i wątkach w organizacji

Maksymalny rozmiar pliku to 512 MB. Każdy plik powinien zawierać nie więcej niż 5 000 000 tokenów (obliczane automatycznie podczas dołączania pliku).

Usuwanie magazynu wektorów

Magazyn wektorów można usunąć z narzędzia wyszukiwania plików.

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}")

Usuwanie magazynów wektorów

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

Zarządzanie kosztami przy użyciu zasad wygasania

W przypadku konfiguracji podstawowego agenta file_search narzędzie używa vector_stores obiektu jako zasobu, a opłaty są naliczane na podstawie rozmiaru utworzonych obiektów vector_store. Rozmiar obiektu magazynu wektorów jest sumą wszystkich analizowanych fragmentów z plików i odpowiadających im osadzeń.

Aby ułatwić zarządzanie kosztami skojarzonymi z tymi obiektami vector_store, dodaliśmy obsługę zasad wygasania vector_store w obiekcie. Te zasady można ustawić podczas tworzenia lub aktualizowania vector_store obiektu.

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
  }
)

Magazyny wektorów wątków mają domyślne zasady wygasania

Magazyny wektorowe utworzone przy użyciu pomocników wątków (na przykład tool_resources.file_search.vector_stores w wątkach lub message.attachments w komunikatach) mają domyślne zasady wygasania z siedmiu dni po tym, jak były ostatnio aktywne (zdefiniowane jako ostatni raz magazyn wektorów był częścią przebiegu).

Po wygaśnięciu magazynu wektorów przebiegi w tym wątku kończą się niepowodzeniem. Aby rozwiązać ten problem, możesz ponownie utworzyć nowy vector_store z tymi samymi plikami i ponownie dołączyć go do wątku.