Outil de recherche de fichiers du service Azure AI Agent

La recherche de fichiers enrichit les agents avec des connaissances extérieures à leur modèle, telles que des informations produit privées ou des documents fournis par vos utilisateurs.

Remarque

À l’aide de la configuration standard de l’agent, l’outil de recherche de fichiers amélioré garantit que vos fichiers restent dans votre propre stockage et que votre ressource Recherche Azure AI est utilisée pour les ingérer, ce qui vous permet de conserver un contrôle total sur vos données.

Sources de fichiers

• Charger des fichiers locaux
• Stockage Blob Azure

Prise en charge de l’utilisation

Prise en charge d’Azure AI Foundry	Kit de développement logiciel (SDK) Python	Kit de développement logiciel (SDK) C#	Kit de développement logiciel (SDK) JavaScript	API REST	Configuration d’agent de base	Configuration d’agent standard
✔️	✔️	✔️	✔️	✔️	Chargement de fichiers uniquement	Chargement de fichiers et utilisation du stockage Blob BYO

Dépendance sur la configuration de l’agent

Configuration d’agent de base

L’outil de recherche de fichiers dispose des mêmes fonctionnalités que les Assistants Azure OpenAI. Les ressources Microsoft managées de recherche et de stockage sont utilisées.

• Les fichiers chargés sont stockés dans le stockage managé de Microsoft
• Un magasin de vecteurs est créé à l’aide d’une ressource de recherche Microsoft managée

Configuration d’agent standard

L’outil de recherche de fichiers utilise les ressources Recherche Azure AI et Stockage Blob Azure que vous avez connectées lors de la configuration de l’agent.

• Les fichiers chargés sont stockés dans votre compte stockage Blob Azure connecté
• Les magasins de vecteurs sont créés à l’aide de votre ressource Recherche Azure AI connectée
  
  

Pour les deux configurations de l’agent, Azure OpenAI gère l’ensemble du processus d’ingestion, notamment :

• Analyse et segmentation automatique des documents
• Génération et stockage d’incorporations
• Utilisation de recherches vectorielles et de mots clés pour récupérer du contenu pertinent pour les requêtes utilisateur.

Il n’existe aucune différence dans le code entre les deux configurations ; la seule variation c’est l’emplacement où vos fichiers et magasins de vecteurs créés sont stockés.

Fonctionnement

L’outil de recherche de fichiers implémente plusieurs meilleures pratiques de récupération de façon native pour vous aider à extraire les données appropriées de vos fichiers et à enrichir les réponses du modèle. L’outil de recherche de fichiers :

• Réécrit les requêtes utilisateur pour les optimiser pour la recherche.
• Décompose les requêtes utilisateur complexes en plusieurs recherches qu’il peut exécuter en parallèle.
• Exécute à la fois des recherches de mots clés et sémantiques dans les magasins de vecteurs d’agent et de thread.
• Reclasse les résultats de recherche pour sélectionner les plus pertinents avant de générer la réponse finale.
• Par défaut, l’outil de recherche de fichiers utilise les paramètres suivants :
  • Taille de bloc : 800 jetons
  • Chevauchement de bloc : 400 jetons
  • Modèle d’incorporation : text-embedding-3-large à 256 dimensions
  • Nombre maximal de blocs ajoutés au contexte : 20

Magasins de vecteurs

Les objets de magasin de vecteurs donnent à l’outil de recherche de fichiers la possibilité de rechercher vos fichiers. L’ajout d’un fichier à un magasin de vecteurs analyse automatiquement, segmente, incorpore, et stocke le fichier dans une base de données de vecteurs capable d’effectuer des recherches de mots clés et sémantiques. Chaque magasin de vecteurs peut contenir jusqu’à 10 000 fichiers. Les magasins de vecteurs peuvent être attachés aux agents et aux threads. Actuellement, vous pouvez attacher au plus un magasin de vecteurs à un agent et au plus un magasin de vecteurs à un thread.

De même, vous pouvez supprimer ces fichiers d’un magasin de vecteurs en procédant comme suit :

• En supprimant l’objet de fichier de magasin de vecteurs ou,
• En supprimant l’objet de fichier sous-jacent, qui supprime le fichier de toutes les configurations vector_store et code_interpreter sur tous les agents et threads de votre organisation

La taille de fichier maximale est de 512 Mo. Chaque fichier ne doit pas contenir plus de 5 000 000 jetons par fichier (calculé automatiquement lorsque vous joignez un fichier).

Garantir la préparation du magasin de vecteurs avant la création d’exécutions

Nous vous recommandons vivement de vous assurer que tous les fichiers d’un vector_store sont entièrement traités avant de créer une exécution. Cela garantit que toutes les données de votre magasin de vecteurs peuvent faire l’objet d’une recherche. Vous pouvez vérifier la préparation du magasin de vecteurs à l’aide des assistances d’interrogation dans les kits SDK, ou en interrogeant manuellement l’objet pour vous assurer que l’état du magasin de vecteurs est Terminé.

En guise de solution de secours, il existe une attente maximale de 60 secondes dans l’objet d’exécution lorsque le magasin de vecteurs du thread contient des fichiers qui sont encore en cours de traitement. Cela permet de s’assurer que tous les fichiers que vos utilisateurs chargent dans un thread peuvent faire l’objet d’une recherche complète avant la poursuite de l’exécution. Cette solution de secours ne s’applique pas au magasin de vecteurs de l’agent.

Ajouter une recherche de fichiers à un agent à l’aide du portail Azure AI Foundry

Vous pouvez ajouter l’outil Recherche Bing à un agent de façon programmatique à l’aide des exemples de code répertoriés en haut de cet article ou proposés dans le portail Azure AI Foundry. Si vous souhaitez utiliser le portail :

1. Dans l’écran Créer et déboguer de votre agent, faites défiler vers le bas le volet Configuration à droite jusqu’à connaissance. Sélectionnez ensuite Ajouter.

   

2. Sélectionnez Fichiers et suivez les invites pour ajouter l’outil.

   

   

Démarrage rapide : Charger des fichiers locaux avec la recherche de fichiers

Dans cet exemple, nous utilisons le service Azure AI Agent pour créer un agent qui peut vous aider à répondre aux questions sur les informations que vous chargez à partir de fichiers locaux.

Prérequis

1. Terminez la configuration de l’agent.

2. Vérifiez que vous disposez du rôle Contributeur aux données Blob de stockage sur le compte de stockage de votre projet.

3. Vérifiez que vous disposez du rôle Azure AI Developer sur votre projet.

Étape 1 : Créer un client de projet

Créez un objet client qui contient la chaîne de connexion visant à se connecter à votre projet IA et à d’autres ressources.

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

Suivez les instructions fournies dans Démarrage rapide de l’API REST pour définir les valeurs appropriées pour les variables d’environnement AZURE_AI_AGENTS_TOKEN et AZURE_AI_AGENTS_ENDPOINT.

Étape 2 : Charger des fichiers et les ajouter à un magasin de vecteurs

Pour accéder à vos fichiers, l’outil de recherche de fichiers utilise l’objet de magasin de vecteurs. Chargez vos fichiers et créez un magasin de vecteurs. Après avoir créé le magasin de vecteurs, interrogez son état jusqu’à ce que tous les fichiers soient hors de l’état in_progress pour vous assurer que tout le contenu est entièrement traité. Le kit de développement logiciel (SDK) fournit une assistance pour le chargement et l’interrogation.

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

Charger un fichier

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"

Créer un magasin vectoriel

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

Joindre le fichier chargé au magasin de vecteurs

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

Étape 3 : Créer un agent et activer la recherche de fichiers

Pour rendre les fichiers accessibles à votre agent, créez un objet FileSearchTool avec l’ID vector_store et attachez tools et tool_resources à l’agent.

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

Étape 4 : Créer un thread

Vous pouvez également joindre des fichiers en tant que pièces jointes de message sur votre thread. Cela crée un autre vector_store associé au thread ou, s’il existe déjà un magasin de vecteurs attaché à ce thread, attache les nouveaux fichiers au magasin de vecteurs de thread existant. Lorsque vous créez une exécution sur ce thread, l’outil de recherche de fichiers interroge à la fois le vector_store de votre agent et le vector_store du thread.

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

Créer un thread

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

Ajouter une question utilisateur au 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?"
    }'

Étape 5 : Créer une exécution et vérifier la sortie

Créez une exécution et vérifiez que le modèle utilise l’outil de recherche de fichiers pour fournir une réponse à la question de l’utilisateur.

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

Exécuter le thread

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

Récupérer l’état de l’exécution

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

Récupérer la réponse de l’agent

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

Démarrage rapide : Utiliser des fichiers existants dans Stockage Blob Azure avec recherche de fichiers

Dans cet exemple, nous utilisons le service Azure AI Agent pour créer un agent qui peut vous aider à répondre aux questions sur les informations provenant de fichiers dans Stockage Blob Azure.

Prérequis

1. Terminez la configuration standard de l’agent

2. Vérifiez que vous disposez du rôle Contributeur aux données Blob de stockage sur le compte de stockage de votre projet.

3. Vérifiez que vous disposez du rôle Azure AI Developer sur votre projet.

Important

La recherche de fichiers à l’aide du stockage Blob est prise en charge uniquement par la configuration standard de l’agent.

Étape 1 : Créer un client de projet

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

Étape 2 : Charger des fichiers locaux dans votre conteneur Stockage Blob Azure de projet

Chargez votre fichier local dans le conteneur Stockage Blob Azure du projet. Il s’agit du même compte de stockage que celui que vous avez connecté à votre agent lors de la configuration. Lors de la création d’agents supplémentaires dans le même projet, vous pouvez réutiliser les URI de ressources de tous les fichiers précédemment chargés dont ces agents ont besoin. Cela signifie que vous n’avez pas besoin de charger le même fichier à plusieurs reprises, car les URI de ressource vous permettent de référencer les fichiers directement.

Ensuite, créez un magasin de vecteurs à l’aide de asset_uri, qui est l’emplacement de votre fichier dans le magasin de données de votre projet.

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

Étape 3 : Créer un agent avec accès à l’outil de recherche de fichiers

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

Étape 4 : Créer un deuxième magasin de vecteurs à l’aide du fichier précédemment chargé

À présent, créez un deuxième magasin de vecteurs à l’aide du fichier précédemment chargé. Utiliser le asset_uri d’un fichier déjà présent dans stockage Blob Azure est utile si vous avez plusieurs agents qui ont besoin d’accéder aux mêmes fichiers, car cela élimine la nécessité de charger le même fichier plusieurs fois.

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

Étape 5 : Créer un deuxième agent avec accès à l’outil de recherche de fichiers

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

Types de fichiers pris en charge

Remarque

Pour les types texte/MIME, le codage doit être utf-8, utf-16 ou ASCII.

Format de fichier	Type MIME
.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

Création de magasins de vecteurs et ajout de fichiers

L’ajout de fichiers à des magasins de vecteurs est une opération asynchrone. Pour vous assurer que l’opération est terminée, nous vous recommandons d’utiliser les assistances « créer et interroger » dans nos kits SDK officiels. Si vous n’utilisez pas les kits SDK, vous pouvez récupérer l’objet vector_store et superviser sa propriété file_counts pour voir le résultat de l’opération d’ingestion de fichier.

Vous pouvez également ajouter des fichiers à un magasin de vecteurs après sa création en créant des fichiers de magasin de vecteurs.

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

Vous pouvez également ajouter plusieurs fichiers à un magasin de vecteurs en créant des lots allant jusqu’à 500 fichiers.

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

Configuration de base de l’agent : supprimer des fichiers à partir de magasins de vecteurs

Vous pouvez supprimer des fichiers d’un magasin de vecteurs en procédant comme suit :

• En supprimant l’objet de fichier de magasin de vecteurs ou,
• Supprimer l’objet de fichier sous-jacent, qui supprime le fichier de toutes les configurations vector_store et code_interpreter sur tous les agents et threads de votre organisation

La taille de fichier maximale est de 512 Mo. Chaque fichier ne doit pas contenir plus de 5 000 000 jetons par fichier (calculé automatiquement lorsque vous joignez un fichier).

Supprimer le magasin de vecteurs

Vous pouvez supprimer un magasin de vecteurs de l’outil de recherche de fichiers.

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

Supprimer des magasins de vecteurs

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

Gestion des coûts avec des stratégies d’expiration

Pour la configuration de base de l’agent, l’outil file_search utilise l’objet vector_stores comme ressource et vous êtes facturé en fonction de la taille des objets vector_store créés. La taille de l’objet de magasin de vecteurs est la somme de tous les blocs analysés de vos fichiers et de leurs incorporations correspondantes.

Pour vous aider à gérer les coûts associés à ces objets vector_store, nous avons ajouté la prise en charge des stratégies d’expiration dans l’objet vector_store. Vous pouvez définir ces stratégies lors de la création ou de la mise à jour de l’objet vector_store.

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

Les magasins de vecteurs de thread ont des stratégies d’expiration par défaut

Les magasins de vecteurs créés à l’aide d’assistances de threads (comme tool_resources.file_search.vector_stores dans les Threads ou message.attachments dans les Messages) ont une stratégie d’expiration par défaut de sept jours après leur dernière activité (définie comme la dernière fois que le magasin de vecteurs faisait partie d’une exécution).

Lorsqu’un magasin de vecteurs expire, les exécutions sur ce thread échouent. Pour résoudre ce problème, vous pouvez recréer un vector_store avec les mêmes fichiers et le rattacher au thread.