Udostępnij za pośrednictwem

Narzędzie wyszukiwania plików Asystentów openAI platformy Azure (wersja zapoznawcza)

  • Artykuł

Wyszukiwanie plików rozszerza asystenta o wiedzę spoza jego modelu, taką jak zastrzeżone informacje o produktach lub dokumenty udostępniane przez użytkowników. Interfejs OpenAI automatycznie analizuje i fragmentuje dokumenty, tworzy i przechowuje elementy osadzone oraz używa wyszukiwania zarówno wektorów, jak i słów kluczowych, aby pobrać odpowiednią zawartość w celu odpowiadania na zapytania użytkowników.

Ważne

  • Z wyszukiwaniem plików wiążą się dodatkowe opłaty poza opłatami opartymi na tokenach za użycie usługi Azure OpenAI.

Uwaga

  • Wyszukiwanie plików może pozyskiwać maksymalnie 10 000 plików na asystenta — 500 razy więcej niż wcześniej. Jest szybkie, obsługuje zapytania równoległe za pośrednictwem wyszukiwania wielowątkowego i oferuje ulepszone ponowne klasyfikowanie praz ponowne zapisywanie zapytań.
    • Magazyn wektorów to nowy obiekt w interfejsie API. Po dodaniu pliku do magazynu wektorów jest on automatycznie analizowany, fragmentowany i osadzany oraz przygotowywany do wyszukiwania. Magazyny wektorów mogą być używane między asystentami i wątkami, upraszczając zarządzanie plikami i rozliczenia.
  • Dodaliśmy obsługę parametru tool_choice , który może służyć do wymuszenia użycia określonego narzędzia (takiego jak wyszukiwanie plików, interpreter kodu lub funkcja) w określonym uruchomieniu.

Obsługa wyszukiwania plików

Obsługiwane regiony

Wyszukiwanie plików jest dostępne w regionach , które obsługują Asystentów.

Wersja interfejsu API

  • 2024-05-01-preview

Typy obsługiwanych plików

Uwaga

W przypadku typów text/MIME kodowanie musi być utf-8, utf-16 lub ASCII.

File format Typ MIME
c. tekst/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 tekst/znaczniki 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 tekst/x-ruby
.Tex text/x-tex
txt text/plain
.Css tekst/css
js text/javascript
.Sh application/x-sh
.Ts application/typescript 
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-05-01-preview",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )

assistant = client.beta.assistants.create(
  name="Financial Analyst Assistant",
  instructions="You are an expert financial analyst. Use your knowledge base to answer questions about audited financial statements.",
  model="gpt-4-turbo",
  tools=[{"type": "file_search"}],
)

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 do ich przechowywania. Po utworzeniu magazynu wektorów należy sondować jego stan, dopóki wszystkie pliki nie będą w in_progress stanie, aby upewnić się, że cała zawartość zakończyła przetwarzanie. Zestaw SDK udostępnia pomocników do przekazywania i sondowania.

from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-05-01-preview",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )

# Create a vector store called "Financial Statements"
vector_store = client.beta.vector_stores.create(name="Financial Statements")
 
# Ready the files for upload to OpenAI
file_paths = ["mydirectory/myfile1.pdf", "mydirectory/myfile2.txt"]
file_streams = [open(path, "rb") for path in file_paths]
 
# Use the upload and poll SDK helper to upload the files, add them to the vector store,
# and poll the status of the file batch for completion.
file_batch = client.beta.vector_stores.file_batches.upload_and_poll(
  vector_store_id=vector_store.id, files=file_streams
)
 
# You can print the status and the file counts of the batch to see the result of this operation.
print(file_batch.status)
print(file_batch.file_counts)

Aktualizowanie asystenta w celu korzystania z nowego magazynu wektorów

Aby pliki były dostępne dla asystenta, zaktualizuj asystenta tool_resources przy użyciu nowego vector_store identyfikatora.

assistant = client.beta.assistants.update(
  assistant_id=assistant.id,
  tool_resources={"file_search": {"vector_store_ids": [vector_store.id]}},
)

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łącz nowe pliki do istniejącego magazynu wektorów wątków. Podczas tworzenia przebiegu w tym wątku narzędzie wyszukiwania plików będzie wysyłać zapytania zarówno vector_store z asystenta, jak i do vector_store wątku.

# Upload the user provided file to OpenAI
message_file = client.files.create(
  file=open("mydirectory/myfile.pdf", "rb"), purpose="assistants"
)
 
# Create a thread and attach the file to the message
thread = client.beta.threads.create(
  messages=[
    {
      "role": "user",
      "content": "How many company shares were outstanding last quarter?",
      # Attach the new file to the message.
      "attachments": [
        { "file_id": message_file.id, "tools": [{"type": "file_search"}] }
      ],
    }
  ]
)
 
# The thread now has a vector store with that file in its tool resources.
print(thread.tool_resources.file_search)

Magazyny wektorów są tworzone przy użyciu załączników komunikatów, które mają domyślne zasady wygasania w ciągu siedmiu dni po ich ostatniej aktywności (zdefiniowanej jako ostatni raz magazyn wektorów był częścią uruchomienia). Ta wartość domyślna ułatwia zarządzanie kosztami magazynu wektorowego. Te zasady wygasania można zastąpić w dowolnym momencie.

Tworzenie przebiegu i sprawdzanie danych wyjściowych

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

from typing_extensions import override
from openai import AssistantEventHandler, OpenAI
 
client = OpenAI()
 
class EventHandler(AssistantEventHandler):
    @override
    def on_text_created(self, text) -> None:
        print(f"\nassistant > ", end="", flush=True)

    @override
    def on_tool_call_created(self, tool_call):
        print(f"\nassistant > {tool_call.type}\n", flush=True)

    @override
    def on_message_done(self, message) -> None:
        # print a citation to the file searched
        message_content = message.content[0].text
        annotations = message_content.annotations
        citations = []
        for index, annotation in enumerate(annotations):
            message_content.value = message_content.value.replace(
                annotation.text, f"[{index}]"
            )
            if file_citation := getattr(annotation, "file_citation", None):
                cited_file = client.files.retrieve(file_citation.file_id)
                citations.append(f"[{index}] {cited_file.filename}")

        print(message_content.value)
        print("\n".join(citations))


# Then, we use the stream SDK helper
# with the EventHandler class to create the Run
# and stream the response.

with client.beta.threads.runs.stream(
    thread_id=thread.id,
    assistant_id=assistant.id,
    instructions="Please address the user as Jane Doe. The user has a premium account.",
    event_handler=EventHandler(),
) as stream:
    stream.until_done()

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 file_search:

  • 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 asystenta, 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 wektorów można dołączać zarówno do asystentów, jak i wątków. Obecnie można dołączyć co najwyżej jeden magazyn wektorów do asystenta i co najwyżej jeden magazyn wektorów do wątku.

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

Możesz utworzyć magazyn wektorów i dodać do niego pliki w jednym wywołaniu interfejsu API:

vector_store = client.beta.vector_stores.create(
  name="Product Documentation",
  file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
)

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.

file = client.beta.vector_stores.files.create_and_poll(
  vector_store_id="vs_abc123",
  file_id="file-abc123"
)

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

batch = client.beta.vector_stores.file_batches.create_and_poll(
  vector_store_id="vs_abc123",
  file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5']
)

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 bazowego (co powoduje usunięcie pliku ze wszystkich konfiguracji vector_store i code_interpreter we wszystkich asystentach 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).

Dołączanie magazynów wektorów

Magazyny wektorów można dołączyć do Asystenta lub Wątku przy użyciu parametru tool_resources.

assistant = client.beta.assistants.create(
  instructions="You are a helpful product support assistant and you answer questions based on the files provided to you.",
  model="gpt-4-turbo",
  tools=[{"type": "file_search"}],
  tool_resources={
    "file_search": {
      "vector_store_ids": ["vs_1"]
    }
  }
)

thread = client.beta.threads.create(
  messages=[ { "role": "user", "content": "How do I cancel my subscription?"} ],
  tool_resources={
    "file_search": {
      "vector_store_ids": ["vs_2"]
    }
  }
)

Możesz również dołączyć magazyn wektorów do wątków lub asystentów po ich utworzeniu, aktualizując je przy użyciu odpowiedniego tool_resourceselementu .

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 vector_store obiekt, 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 asystenta.

Zarządzanie kosztami przy użyciu zasad wygasania

Narzędzie file_search używa vector_stores obiektu jako zasobu i zostanie naliczone opłaty 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 w vector_store obiekcie. Te zasady można ustawić podczas tworzenia lub aktualizowania vector_store obiektu.

vector_store = client.beta.vector_stores.create_and_poll(
  name="Product Documentation",
  file_ids=['file_1', 'file_2', 'file_3', 'file_4', 'file_5'],
  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 uruchomienie tego wątku zakończy 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.

all_files = list(client.beta.vector_stores.files.list("vs_expired"))

vector_store = client.beta.vector_stores.create(name="rag-store")
client.beta.threads.update(
    "thread_abc123",
    tool_resources={"file_search": {"vector_store_ids": [vector_store.id]}},
)

for file_batch in chunked(all_files, 100):
    client.beta.vector_stores.file_batches.create_and_poll(
        vector_store_id=vector_store.id, file_ids=[file.id for file in file_batch]
    )