Condividi tramite

Incorporamenti OpenAI di Azure archivia l'associazione di output per Funzioni di Azure

  • Articolo

Importante

L'estensione OpenAI di Azure per Funzioni di Azure è attualmente in anteprima.

L'associazione di output dell'archivio di incorporamenti OpenAI di Azure consente di scrivere file in un archivio documenti semantico a cui è possibile fare riferimento in un secondo momento in una ricerca semantica.

Per informazioni sull'installazione e la configurazione dell'estensione OpenAI di Azure, vedere Estensioni OpenAI di Azure per Funzioni di Azure. Per altre informazioni sulla classificazione semantica in Ricerca di intelligenza artificiale di Azure, vedere Classificazione semantica in Ricerca di intelligenza artificiale di Azure.

Nota

I riferimenti e gli esempi vengono forniti solo per il modello Node.js v4.

Nota

I riferimenti e gli esempi vengono forniti solo per il modello Python v2.

Nota

Anche se sono supportati entrambi i modelli di processo C#, vengono forniti solo esempi di modelli di lavoro isolati.

Esempio

Questo esempio scrive un flusso di input HTTP in un archivio documenti semantico nell'URL fornito.

[Function("IngestFile")]
public static async Task<EmbeddingsStoreOutputResponse> IngestFile(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
{
    ArgumentNullException.ThrowIfNull(req);

    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    if (string.IsNullOrWhiteSpace(request))
    {
        throw new ArgumentException("Request body is empty.");
    }

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);

    if (string.IsNullOrWhiteSpace(requestBody?.Url))
    {
        throw new ArgumentException("Invalid request body. Make sure that you pass in {\"url\": value } as the request body.");
    }

    if (!Uri.TryCreate(requestBody.Url, UriKind.Absolute, out Uri? uri))
    {
        throw new ArgumentException("Invalid Url format.");
    }

    string filename = Path.GetFileName(uri.AbsolutePath);

    return new EmbeddingsStoreOutputResponse
    {
        HttpResponse = new OkObjectResult(new { status = HttpStatusCode.OK }),
        SearchableDocument = new SearchableDocument(filename)
    };
}

public class EmbeddingsStoreOutputResponse
{
    [EmbeddingsStoreOutput("{url}", InputType.Url, "AISearchEndpoint", "openai-index", Model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%")]
    public required SearchableDocument SearchableDocument { get; init; }

    public IActionResult? HttpResponse { get; set; }
}

Questo esempio scrive un flusso di input HTTP in un archivio documenti semantico nell'URL fornito.

import com.microsoft.azure.functions.openai.annotation.search.SearchableDocument;
import com.microsoft.azure.functions.openai.annotation.search.SemanticSearch;

public class FilePrompt {

    @FunctionName("IngestFile")
    public HttpResponseMessage ingestFile(
        @HttpTrigger(
            name = "req", 
            methods = {HttpMethod.POST},
            authLevel = AuthorizationLevel.ANONYMOUS)
            HttpRequestMessage<EmbeddingsRequest> request,
        @EmbeddingsStoreOutput(name="EmbeddingsStoreOutput", input = "{url}", inputType = InputType.Url,
                connectionName = "AISearchEndpoint", collection = "openai-index",
                model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%") OutputBinding<EmbeddingsStoreOutputResponse> output,
        final ExecutionContext context) throws URISyntaxException {

        if (request.getBody() == null || request.getBody().getUrl() == null)
        {
            throw new IllegalArgumentException("Invalid request body. Make sure that you pass in {\"url\": value } as the request body.");
        }

        URI uri = new URI(request.getBody().getUrl());
        String filename = Paths.get(uri.getPath()).getFileName().toString();

        EmbeddingsStoreOutputResponse embeddingsStoreOutputResponse = new EmbeddingsStoreOutputResponse(new SearchableDocument(filename));

        output.setValue(embeddingsStoreOutputResponse);

        JSONObject response = new JSONObject();
        response.put("status", "success");
        response.put("title", filename);

        return request.createResponseBuilder(HttpStatus.CREATED)
                .header("Content-Type", "application/json")
                .body(response)
                .build();
    }

    public class EmbeddingsStoreOutputResponse {
        private SearchableDocument searchableDocument;

        public EmbeddingsStoreOutputResponse(SearchableDocument searchableDocument) {
            this.searchableDocument = searchableDocument;
        }

Questo esempio scrive un flusso di input HTTP in un archivio documenti semantico nell'URL fornito.

const embeddingsStoreOutput = output.generic({
    type: "embeddingsStore",
    input: "{url}", 
    inputType: "url", 
    connectionName: "AISearchEndpoint", 
    collection: "openai-index", 
    model: "%EMBEDDING_MODEL_DEPLOYMENT_NAME%"
});

app.http('IngestFile', {
    methods: ['POST'],
    authLevel: 'function',
    extraOutputs: [embeddingsStoreOutput],
    handler: async (request, context) => {
        let requestBody = await request.json();
        if (!requestBody || !requestBody.url) {
            throw new Error("Invalid request body. Make sure that you pass in {\"url\": value } as the request body.");
        }

        let uri = requestBody.url;
        let url = new URL(uri);

        let fileName = path.basename(url.pathname);
        context.extraOutputs.set(embeddingsStoreOutput, { title: fileName });

        let response = {
            status: "success",
            title: fileName
        };

        return { status: 202, jsonBody: response } 
    }
});

interface EmbeddingsRequest {
    url?: string;
}

const embeddingsStoreOutput = output.generic({
    type: "embeddingsStore",
    input: "{url}", 
    inputType: "url", 
    connectionName: "AISearchEndpoint", 
    collection: "openai-index", 
    model: "%EMBEDDING_MODEL_DEPLOYMENT_NAME%"
});

app.http('IngestFile', {
    methods: ['POST'],
    authLevel: 'function',
    extraOutputs: [embeddingsStoreOutput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsRequest | null = await request.json();
        if (!requestBody || !requestBody.url) {
            throw new Error("Invalid request body. Make sure that you pass in {\"url\": value } as the request body.");
        }

        let uri = requestBody.url;
        let url = new URL(uri);

        let fileName = path.basename(url.pathname);
        context.extraOutputs.set(embeddingsStoreOutput, { title: fileName });

        let response = {
            status: "success",
            title: fileName
        };

        return { status: 202, jsonBody: response } 
    }
});

Questo esempio scrive un flusso di input HTTP in un archivio documenti semantico nell'URL fornito.

Ecco il file function.json per l'inserimento di file:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "name": "EmbeddingsStoreOutput",
      "type": "embeddingsStore",
      "direction": "out",
      "input": "{url}",
      "inputType": "Url",
      "connectionName": "AISearchEndpoint",
      "collection": "openai-index",
      "model": "%EMBEDDING_MODEL_DEPLOYMENT_NAME%"
    }
  ]
}

Per altre informazioni sulle proprietà dei file function.json, vedere la sezione configurazione.

using namespace System.Net

param($Request, $TriggerMetadata)

$ErrorActionPreference = 'Stop'

$inputJson = $Request.Body

if (-not $inputJson -or -not $inputJson.Url) {
    throw 'Invalid request body. Make sure that you pass in {\"url\": value } as the request body.'
}

$uri = [URI]$inputJson.Url
$filename = [System.IO.Path]::GetFileName($uri.AbsolutePath)


Push-OutputBinding -Name EmbeddingsStoreOutput -Value @{
    "title" = $filename
}

$response = @{
    "status" = "success"
    "title" = $filename
}

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::OK
        Body = $response
        Headers    = @{
            "Content-Type" = "application/json"
        }
})

Questo esempio scrive un flusso di input HTTP in un archivio documenti semantico nell'URL fornito.

@app.function_name("IngestFile")
@app.route(methods=["POST"])
@app.embeddings_store_output(arg_name="requests", input="{url}", input_type="url", connection_name="AISearchEndpoint", collection="openai-index", model="%EMBEDDING_MODEL_DEPLOYMENT_NAME%")
def ingest_file(req: func.HttpRequest, requests: func.Out[str]) -> func.HttpResponse:
    user_message = req.get_json()
    if not user_message:
        return func.HttpResponse(json.dumps({"message": "No message provided"}), status_code=400, mimetype="application/json")
    file_name_with_extension = os.path.basename(user_message["url"])
    title = os.path.splitext(file_name_with_extension)[0]
    create_request = {
        "title": title
    }
    requests.set(json.dumps(create_request))
    response_json = {
        "status": "success",
        "title": title
    }
    return func.HttpResponse(json.dumps(response_json), status_code=200, mimetype="application/json")

Attributi

Applicare l'attributo EmbeddingsStoreOutput per definire un'associazione di output dell'archivio incorporamenti, che supporta questi parametri:

Parametro Descrizione
Input Stringa di input per cui generare incorporamenti.
Modello Facoltativo. ID del modello da usare, che per impostazione predefinita è text-embedding-ada-002. Non è consigliabile modificare il modello per un database esistente. Per altre informazioni, vedere Utilizzo.
MaxChunkLength Facoltativo. Numero massimo di caratteri utilizzati per la suddivisione in blocchi dell'input. Per altre informazioni, vedere Utilizzo.
MaxOverlap Facoltativo. Ottiene o imposta il numero massimo di caratteri da sovrapporre tra blocchi.
InputType Facoltativo. Ottiene il tipo dell'input.
ConnectionName Nome di un'impostazione dell'app o di una variabile di ambiente che contiene il valore della stringa di connessione. Questa proprietà supporta le espressioni di associazione.
Raccolta Nome della raccolta, della tabella o dell'indice da cercare. Questa proprietà supporta le espressioni di associazione.

Annotazioni

L'annotazione EmbeddingsStoreOutput consente di definire un'associazione di output dell'archivio incorporamenti, che supporta questi parametri:

Elemento Descrizione
name Ottiene o imposta il nome dell'associazione di output.
input Stringa di input per cui generare incorporamenti.
model Facoltativo. ID del modello da usare, che per impostazione predefinita è text-embedding-ada-002. Non è consigliabile modificare il modello per un database esistente. Per altre informazioni, vedere Utilizzo.
maxChunkLength Facoltativo. Numero massimo di caratteri utilizzati per la suddivisione in blocchi dell'input. Per altre informazioni, vedere Utilizzo.
maxOverlap Facoltativo. Ottiene o imposta il numero massimo di caratteri da sovrapporre tra blocchi.
inputType Facoltativo. Ottiene il tipo dell'input.
connectionName Nome di un'impostazione dell'app o di una variabile di ambiente che contiene il valore della stringa di connessione. Questa proprietà supporta le espressioni di associazione.
collection Nome della raccolta, della tabella o dell'indice da cercare. Questa proprietà supporta le espressioni di associazione.

Elementi Decorator

Durante l'anteprima, definire l'associazione di output come associazione generic_output_binding di tipo semanticSearch, che supporta questi parametri:

Parametro Descrizione
arg_name Nome della variabile che rappresenta il parametro di associazione.
input Stringa di input per cui generare incorporamenti.
model Facoltativo. ID del modello da usare, che per impostazione predefinita è text-embedding-ada-002. Non è consigliabile modificare il modello per un database esistente. Per altre informazioni, vedere Utilizzo.
maxChunkLength Facoltativo. Numero massimo di caratteri utilizzati per la suddivisione in blocchi dell'input. Per altre informazioni, vedere Utilizzo.
max_overlap Facoltativo. Ottiene o imposta il numero massimo di caratteri da sovrapporre tra blocchi.
input_type Ottiene il tipo dell'input.
connection_name Nome di un'impostazione dell'app o di una variabile di ambiente che contiene il valore della stringa di connessione. Questa proprietà supporta le espressioni di associazione.
collection Nome della raccolta, della tabella o dell'indice da cercare. Questa proprietà supporta le espressioni di associazione.

Impostazione

L'associazione supporta queste proprietà di configurazione impostate nel file function.json.

Proprietà Descrizione
type Deve essere embeddingsStore.
direction Deve essere out.
name Nome dell'associazione di output.
input Stringa di input per cui generare incorporamenti.
model Facoltativo. ID del modello da usare, che per impostazione predefinita è text-embedding-ada-002. Non è consigliabile modificare il modello per un database esistente. Per altre informazioni, vedere Utilizzo.
maxChunkLength Facoltativo. Numero massimo di caratteri utilizzati per la suddivisione in blocchi dell'input. Per altre informazioni, vedere Utilizzo.
maxOverlap Facoltativo. Ottiene o imposta il numero massimo di caratteri da sovrapporre tra blocchi.
inputType Facoltativo. Ottiene il tipo dell'input.
connectionName Nome di un'impostazione dell'app o di una variabile di ambiente che contiene il valore della stringa di connessione. Questa proprietà supporta le espressioni di associazione.
collection Nome della raccolta, della tabella o dell'indice da cercare. Questa proprietà supporta le espressioni di associazione.

Impostazione

Il binding supporta queste proprietà, definite nel codice:

Proprietà Descrizione
input Stringa di input per cui generare incorporamenti.
model Facoltativo. ID del modello da usare, che per impostazione predefinita è text-embedding-ada-002. Non è consigliabile modificare il modello per un database esistente. Per altre informazioni, vedere Utilizzo.
maxChunkLength Facoltativo. Numero massimo di caratteri utilizzati per la suddivisione in blocchi dell'input. Per altre informazioni, vedere Utilizzo.
maxOverlap Facoltativo. Ottiene o imposta il numero massimo di caratteri da sovrapporre tra blocchi.
inputType Facoltativo. Ottiene il tipo dell'input.
connectionName Nome di un'impostazione dell'app o di una variabile di ambiente che contiene il valore della stringa di connessione. Questa proprietà supporta le espressioni di associazione.
collection Nome della raccolta, della tabella o dell'indice da cercare. Questa proprietà supporta le espressioni di associazione.

Utilizzo

Per esempi completi, vedere la sezione di esempio.

Contenuto correlato