Azure OpenAI-Einbettungseingabebindung für Azure Functions

Wichtig

Die Azure OpenAI-Erweiterung für Azure Functions befindet sich derzeit in der Vorschau.

Mit der Azure OpenAI-Einbettungseingabebindung können Sie Einbettungen für Eingaben generieren. Die Bindung kann Einbettungen aus Dateien oder unformatierten Texteingaben generieren.

Informationen zu Einrichtungs- und Konfigurationsdetails der Azure OpenAI-Erweiterung finden Sie unter Azure OpenAI-Erweiterungen für Azure Functions. Weitere Informationen zu Einbettungen in Azure OpenAI-Dienst finden Sie unter Grundlegendes zu Einbettungen in Azure OpenAI Service.

Hinweis

Referenzen und Beispiele werden nur für das Node.js v4-Modell bereitgestellt.

Hinweis

Referenzen und Beispiele werden nur für das Python v2-Modell bereitgestellt.

Hinweis

Während beide C#-Prozessmodelle unterstützt werden, werden nur Isolierte Arbeitsmodellbeispiele bereitgestellt.

Beispiel

In diesem Beispiel wird gezeigt, wie Einbettungen für eine unformatierte Textzeichenfolge generiert werden.

[Function(nameof(GenerateEmbeddings_Http_RequestAsync))]
public async Task GenerateEmbeddings_Http_RequestAsync(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings")] HttpRequestData req,
    [EmbeddingsInput("{rawText}", InputType.RawText, Model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

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

    this.logger.LogInformation(
        "Received {count} embedding(s) for input text containing {length} characters.",
        embeddings.Count,
        requestBody?.RawText?.Length);

    // TODO: Store the embeddings into a database or other storage.
}

In diesem Beispiel wird gezeigt, wie Einbettungen abgerufen werden, die in einer angegebenen Datei gespeichert sind, auf die für die Funktion zugegriffen werden kann.

[Function(nameof(GetEmbeddings_Http_FilePath))]
public async Task GetEmbeddings_Http_FilePath(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "embeddings-from-file")] HttpRequestData req,
    [EmbeddingsInput("{filePath}", InputType.FilePath, MaxChunkLength = 512, Model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%")] EmbeddingsContext embeddings)
{
    using StreamReader reader = new(req.Body);
    string request = await reader.ReadToEndAsync();

    EmbeddingsRequest? requestBody = JsonSerializer.Deserialize<EmbeddingsRequest>(request);
    this.logger.LogInformation(
        "Received {count} embedding(s) for input file '{path}'.",
        embeddings.Count,
        requestBody?.FilePath);

    // TODO: Store the embeddings into a database or other storage.
}

In diesem Beispiel wird gezeigt, wie Einbettungen für eine unformatierte Textzeichenfolge generiert werden.

@FunctionName("GenerateEmbeddingsHttpRequest")
public HttpResponseMessage generateEmbeddingsHttpRequest(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.POST},
        authLevel = AuthorizationLevel.ANONYMOUS,
        route = "embeddings")
    HttpRequestMessage<EmbeddingsRequest> request,
    @EmbeddingsInput(name = "Embeddings", input = "{RawText}", inputType = InputType.RawText, model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%") String embeddingsContext,
    final ExecutionContext context) {

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

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);
    
    context.getLogger().info(String.format("Received %d embedding(s) for input text containing %s characters.",
            embeddingsContextJsonObject.getJSONObject("response")
                    .getJSONArray("data")
                    .getJSONObject(0)
                    .getJSONArray("embedding").length(),
            request.getBody().getRawText().length()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

In diesem Beispiel wird gezeigt, wie Einbettungen abgerufen werden, die in einer angegebenen Datei gespeichert sind, auf die für die Funktion zugegriffen werden kann.

@FunctionName("GenerateEmbeddingsHttpFilePath")
public HttpResponseMessage generateEmbeddingsHttpFilePath(
    @HttpTrigger(
        name = "req", 
        methods = {HttpMethod.POST},
        authLevel = AuthorizationLevel.ANONYMOUS,
        route = "embeddings-from-file")
    HttpRequestMessage<EmbeddingsRequest> request,
    @EmbeddingsInput(name = "Embeddings", input = "{FilePath}", inputType = InputType.FilePath, maxChunkLength = 512, model = "%EMBEDDING_MODEL_DEPLOYMENT_NAME%") String embeddingsContext,
    final ExecutionContext context) {

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

    JSONObject embeddingsContextJsonObject = new JSONObject(embeddingsContext);
    
    context.getLogger().info(String.format("Received %d embedding(s) for input file %s.",
            embeddingsContextJsonObject.getJSONObject("response")
                    .getJSONArray("data")
                    .getJSONObject(0)
                    .getJSONArray("embedding").length(),
            request.getBody().getFilePath()));

    // TODO: Store the embeddings into a database or other storage.
    return request.createResponseBuilder(HttpStatus.ACCEPTED)
            .header("Content-Type", "application/json")
            .build();
}

Beispiele sind noch nicht verfügbar.

In diesem Beispiel wird gezeigt, wie Einbettungen für eine unformatierte Textzeichenfolge generiert werden.

const embeddingsHttpInput = input.generic({
    input: '{rawText}',
    inputType: 'RawText',
    type: 'embeddings',
    model: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%'
})

app.http('generateEmbeddings', {
    methods: ['POST'],
    route: 'embeddings',
    authLevel: 'function',
    extraInputs: [embeddingsHttpInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsHttpRequest = await request.json();
        let response: any = context.extraInputs.get(embeddingsHttpInput);

        context.log(
            `Received ${response.count} embedding(s) for input text containing ${requestBody.RawText.length} characters.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }
});

In diesem Beispiel wird gezeigt, wie Einbettungen abgerufen werden, die in einer angegebenen Datei gespeichert sind, auf die für die Funktion zugegriffen werden kann.

const embeddingsFilePathInput = input.generic({
    input: '{filePath}',
    inputType: 'FilePath',
    type: 'embeddings',
    maxChunkLength: 512,
    model: '%EMBEDDING_MODEL_DEPLOYMENT_NAME%'
})

app.http('getEmbeddingsFilePath', {
    methods: ['POST'],
    route: 'embeddings-from-file',
    authLevel: 'function',
    extraInputs: [embeddingsFilePathInput],
    handler: async (request, context) => {
        let requestBody: EmbeddingsFilePath = await request.json();
        let response: any = context.extraInputs.get(embeddingsFilePathInput);

        context.log(
            `Received ${response.count} embedding(s) for input file ${requestBody.FilePath}.`
        );
        
        // TODO: Store the embeddings into a database or other storage.

        return {status: 202}
    }

In diesem Beispiel wird gezeigt, wie Einbettungen für eine unformatierte Textzeichenfolge generiert werden.

Dies ist die function.json Datei zum Generieren der Einbettungen:

{
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "route": "embeddings",
      "methods": [
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "name": "Embeddings",
      "type": "embeddings",
      "direction": "in",
      "inputType": "RawText",
      "input": "{rawText}",
      "model": "%EMBEDDING_MODEL_DEPLOYMENT_NAME%"
    }
  ]
}

Weitere Informationen zu den Dateieigenschaften von function.json finden Sie im Abschnitt Konfiguration.

using namespace System.Net

param($Request, $TriggerMetadata, $Embeddings)

$input = $Request.Body.RawText

Write-Host "Received $($Embeddings.Count) embedding(s) for input text containing $($input.Length) characters."

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
        StatusCode = [HttpStatusCode]::Accepted
})

In diesem Beispiel wird gezeigt, wie Einbettungen für eine unformatierte Textzeichenfolge generiert werden.

@app.function_name("GenerateEmbeddingsHttpRequest")
@app.route(route="embeddings", methods=["POST"])
@app.embeddings_input(arg_name="embeddings", input="{rawText}", input_type="rawText", model="%EMBEDDING_MODEL_DEPLOYMENT_NAME%")
def generate_embeddings_http_request(req: func.HttpRequest, embeddings: str) -> func.HttpResponse:
    user_message = req.get_json()
    embeddings_json = json.loads(embeddings)
    embeddings_request = {
        "raw_text": user_message.get("rawText")
    }
    logging.info(f'Received {embeddings_json.get("count")} embedding(s) for input text '
        f'containing {len(embeddings_request.get("raw_text"))} characters.')
    # TODO: Store the embeddings into a database or other storage.
    return func.HttpResponse(status_code=200)

Attribute

Wenden Sie das EmbeddingsInput-Attribut an, um eine Einbettungseingabebindung zu definieren, die diese Parameter unterstützt:

Parameter	Beschreibung
Eingabe	Die Eingabezeichenfolge, für die Einbettungen generiert werden sollen.
Modell	Optional. Die ID des zu verwendenden Modells, die standardmäßig text-embedding-ada-002 lautet. Sie sollten das Modell für eine vorhandene Datenbank nicht ändern. Weitere Informationen finden Sie unter Verbrauch.
MaxChunkLength	Optional. Die maximale Anzahl von Zeichen, die für die Segmentierung der Eingabe verwendet werden. Weitere Informationen finden Sie unter Verbrauch.
MaxOverlap	Optional. Ruft die maximale Anzahl von Zeichen ab, die zwischen Blöcken überlappen sollen, oder legt diese fest.
InputType	Optional. Ruft den Typ der Eingabe ab.

Anmerkungen

Mit der EmbeddingsInput-Anmerkung können Sie eine Einbettungseingabebindung definieren, die diese Parameter unterstützt:

Element	BESCHREIBUNG
name	Ruft den Namen der Eingabebindung ab oder legt ihn fest.
input	Die Eingabezeichenfolge, für die Einbettungen generiert werden sollen.
Modell	Optional. Die ID des zu verwendenden Modells, die standardmäßig text-embedding-ada-002 lautet. Sie sollten das Modell für eine vorhandene Datenbank nicht ändern. Weitere Informationen finden Sie unter Verbrauch.
maxChunkLength	Optional. Die maximale Anzahl von Zeichen, die für die Segmentierung der Eingabe verwendet werden. Weitere Informationen finden Sie unter Verbrauch.
maxOverlap	Optional. Ruft die maximale Anzahl von Zeichen ab, die zwischen Blöcken überlappen sollen, oder legt diese fest.
inputType	Optional. Ruft den Typ der Eingabe ab.

Decorator-Elemente

Definieren Sie während der Vorschau die Eingabebindung als generic_input_binding-Bindung vom Typ „embeddings“, die diese Parameter unterstützt: embeddings-Decorator unterstützt die folgenden Parameter:

Parameter	Beschreibung
arg_name	Der Name der Variablen, die den Bindungsparameter darstellt.
input	Die Eingabezeichenfolge, für die Einbettungen generiert werden sollen.
Modell	Optional. Die ID des zu verwendenden Modells, die standardmäßig text-embedding-ada-002 lautet. Sie sollten das Modell für eine vorhandene Datenbank nicht ändern. Weitere Informationen finden Sie unter Verbrauch.
maxChunkLength	Optional. Die maximale Anzahl von Zeichen, die für die Segmentierung der Eingabe verwendet werden. Weitere Informationen finden Sie unter Verbrauch.
max_overlap	Optional. Ruft die maximale Anzahl von Zeichen ab, die zwischen Blöcken überlappen sollen, oder legt diese fest.
input_type	Ruft den Typ der Eingabe ab.

Konfiguration

Die Bindung unterstützt diese Konfigurationseigenschaften, die Sie in der Datei „function.json“ festlegen.

Eigenschaft	Beschreibung des Dataflows
type	Muss EmbeddingsInputlauten.
direction	Muss inlauten.
name	Der Name der Eingabebindung.
input	Die Eingabezeichenfolge, für die Einbettungen generiert werden sollen.
Modell	Optional. Die ID des zu verwendenden Modells, die standardmäßig text-embedding-ada-002 lautet. Sie sollten das Modell für eine vorhandene Datenbank nicht ändern. Weitere Informationen finden Sie unter Verbrauch.
maxChunkLength	Optional. Die maximale Anzahl von Zeichen, die für die Segmentierung der Eingabe verwendet werden. Weitere Informationen finden Sie unter Verbrauch.
maxOverlap	Optional. Ruft die maximale Anzahl von Zeichen ab, die zwischen Blöcken überlappen sollen, oder legt diese fest.
inputType	Optional. Ruft den Typ der Eingabe ab.

Konfiguration

Die Bindung unterstützt diese Eigenschaften, die in Ihrem Code definiert sind:

Eigenschaft	Beschreibung
input	Die Eingabezeichenfolge, für die Einbettungen generiert werden sollen.
Modell	Optional. Die ID des zu verwendenden Modells, die standardmäßig text-embedding-ada-002 lautet. Sie sollten das Modell für eine vorhandene Datenbank nicht ändern. Weitere Informationen finden Sie unter Verbrauch.
maxChunkLength	Optional. Die maximale Anzahl von Zeichen, die für die Segmentierung der Eingabe verwendet werden. Weitere Informationen finden Sie unter Verbrauch.
maxOverlap	Optional. Ruft die maximale Anzahl von Zeichen ab, die zwischen Blöcken überlappen sollen, oder legt diese fest.
inputType	Optional. Ruft den Typ der Eingabe ab.

Vollständige Beispiele finden Sie im Abschnitt Beispiele.

Verbrauch

Das Ändern der Standardeinbettungen „model“ ändert die Art und Weise, wie Einbettungen in der Vektordatenbank gespeichert werden. Das Ändern des Standardmodells kann dazu führen, dass die Nachschlagevorgänge fehlschlagen, wenn sie nicht mit den restlichen Daten übereinstimmen, die zuvor in die Vektordatenbank aufgenommen wurden. Das Standardmodell für Einbettungen ist text-embedding-ada-002.

Berücksichtigen Sie bei der Berechnung der maximalen Zeichenlänge für Eingabeblöcke, dass die maximal zulässigen Eingabetoken für Einbettungsmodelle der zweiten Generation wie text-embedding-ada-002 wie 8191 aussehen. Ein einzelnes Token ist ungefähr vier Zeichen lang (in Englisch), was in etwa 32.000 Zeichen (Englisch) der Eingabe entspricht, die in einen einzelnen Block passen können.

Zugehöriger Inhalt

• Einbettungsbeispiele
• Azure OpenAI-Erweiterungen für Azure Functions