Referencia de la API / Conocimiento y búsqueda vectorial

Iniciar un trabajo de conocimiento

POSThttps://ai.inovacc.dev/v1/knowledge/jobs

Inicia la construcción de una base de conocimiento a partir de una carga completada de una grabación.

Parámetros del cuerpo

upload_idstringobligatorio
El id de una carga completada de la grabación (su X-Operation-Id en POST /v1/uploads).
max_price_usdstringobligatorio
Lo máximo que puede costar el trabajo, un decimal mayor que cero como "5.00". Si supera el tope de tu organización, se rechaza antes de cualquier trabajo de pago.
spoken_languagestring
El idioma de la grabación, como en o pt-BR: una pista para la transcripción.
output_languagestring
El idioma en que se escribe la base de conocimiento. Predeterminado inglés; las citas y la transcripción nunca se traducen.
power"light" | "medium" | "max"
El ajuste de calidad. Predeterminado medium; light desactiva la conciliación de evidencia y la extracción.
max_pointersinteger
Cuántos fotogramas fijos puede referenciar la base de conocimiento, de 1 a 50.
keep_source_hoursinteger
Conserva la grabación tras el trabajo, para que otro trabajo pueda reutilizarla: de 1 a 168 horas, dentro del tope de tu organización.
referencesobject
Material de apoyo: transcript y notes, cada uno el id de una carga completada de máximo 16 MiB.
transcriptstring
La transcripción propia de la reunión; los nombres de los hablantes que incluya mejoran la atribución de quién dijo qué.
notesstring
Un documento de notas de apoyo, en texto plano o Markdown.
adaptive_evidence_reconciliationobject
{"enabled": false} omite verificar cada entrada contra la evidencia. Predeterminado según power.
adaptive_evidence_extractionobject
{"enabled": false} no captura fotogramas. Predeterminado según power.

Encabezados

Authorizationstringobligatorio
Bearer <clave de API>
X-Operation-Idstringobligatorio
un id único que tú eliges, en toda llamada excepto GET
Content-Typestringobligatorio
application/json, en una llamada con cuerpo

Ver también

Detalles de la fuente

Entrada del catálogo

Id: identity/component-taxonomy/capabilities#knowledge
Repositorio: identity
Ruta: contracts/component-taxonomy/catalog/capabilities.json
Commit: 08ef3cd75d82

Sección del contrato

Id: ai/ai/contract#post-v1knowledgejobs
Repositorio: ai
Ruta: apps/cloudflare/workers/api/ai/CONTRACT.md
Commit: 972a1c15b9d5
Versión documentada: 2.37.0
Versión en producción: 2.14.0

Solicitud en cURLEjemplo

cURL

1
2
3
4
5
6
7
8
9
10
11
12
13curl -X POST "https://ai.inovacc.dev/v1/knowledge/jobs" \
  -H "Authorization: Bearer $INOVACC_API_KEY" \
  -H "X-Operation-Id: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
}'

TypeScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import crypto from "node:crypto";

const body: Record<string, unknown> = {
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
};

const url = "https://ai.inovacc.dev/v1/knowledge/jobs";

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
    "X-Operation-Id": crypto.randomUUID(),
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});

console.log(response.status, await response.text());

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import json
import os
import urllib.request
import uuid

body = {
    "upload_id": "client_up_00000001",
    "spoken_language": "en",
    "max_price_usd": "5.00",
    "references": {
        "transcript": "client_up_transcript01",
        "notes": "client_up_notes000001",
    },
}

request = urllib.request.Request(
    "https://ai.inovacc.dev/v1/knowledge/jobs",
    data=json.dumps(body).encode(),
    method="POST",
    headers={
        "User-Agent": "inovacc-python-sample",
        "Authorization": "Bearer " + os.environ["INOVACC_API_KEY"],
        "X-Operation-Id": str(uuid.uuid4()),
        "Content-Type": "application/json",
    },
)

with urllib.request.urlopen(request) as response:
    print(response.status, response.read().decode())

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55package main

import (
	"crypto/rand"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

const url = "https://ai.inovacc.dev/v1/knowledge/jobs"

const body = `{
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
}`

// newUUID returns a random (version 4) UUID, from the standard library alone.
func newUUID() string {
	b := make([]byte, 16)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}
	b[6] = b[6]&0x0f | 0x40
	b[8] = b[8]&0x3f | 0x80
	return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}

func main() {
	req, err := http.NewRequest("POST", url, strings.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INOVACC_API_KEY"))
	req.Header.Set("X-Operation-Id", newUUID())
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Status, string(out))
}

Rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24// Cargo.toml: reqwest = { version = "0.12", features = ["blocking", "json"] }
// Cargo.toml: serde_json = "1"
// Cargo.toml: uuid = { version = "1", features = ["v4"] }

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("INOVACC_API_KEY")?;
    let body = serde_json::json!({
        "upload_id": "client_up_00000001",
        "spoken_language": "en",
        "max_price_usd": "5.00",
        "references": {
            "transcript": "client_up_transcript01",
            "notes": "client_up_notes000001"
        }
    });
    let response = reqwest::blocking::Client::new()
        .post("https://ai.inovacc.dev/v1/knowledge/jobs")
        .bearer_auth(api_key)
        .header("X-Operation-Id", uuid::Uuid::new_v4().to_string())
        .json(&body)
        .send()?;
    println!("{} {}", response.status(), response.text()?);
    Ok(())
}

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import crypto from "node:crypto";

const body = {
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
};

const url = "https://ai.inovacc.dev/v1/knowledge/jobs";

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.INOVACC_API_KEY}`,
    "X-Operation-Id": crypto.randomUUID(),
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
});

console.log(response.status, await response.text());

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37<?php

$body = <<<'JSON'
{
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
}
JSON;

function uuid4(): string
{
    $bytes = random_bytes(16);
    $bytes[6] = chr(ord($bytes[6]) & 0x0f | 0x40);
    $bytes[8] = chr(ord($bytes[8]) & 0x3f | 0x80);
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($bytes), 4));
}

$curl = curl_init('https://ai.inovacc.dev/v1/knowledge/jobs');
curl_setopt_array($curl, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . getenv('INOVACC_API_KEY'),
        'X-Operation-Id: ' . uuid4(),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => $body,
]);

$response = curl_exec($curl);
echo curl_getinfo($curl, CURLINFO_HTTP_CODE), ' ', $response, "\n";
curl_close($curl);

Ruby

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28require "net/http"
require "securerandom"
require "uri"

uri = URI('https://ai.inovacc.dev/v1/knowledge/jobs')
body = <<~'JSON'
{
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
}
JSON

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch('INOVACC_API_KEY')}"
request["X-Operation-Id"] = SecureRandom.uuid
request["Content-Type"] = "application/json"
request.body = body

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts "#{response.code} #{response.body}"

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.UUID;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("INOVACC_API_KEY");
        String body = "{" +
                "\"upload_id\": \"client_up_00000001\"," +
                "\"spoken_language\": \"en\"," +
                "\"max_price_usd\": \"5.00\"," +
                "\"references\": {" +
                "\"transcript\": \"client_up_transcript01\"," +
                "\"notes\": \"client_up_notes000001\"" +
                "}" +
                "}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://ai.inovacc.dev/v1/knowledge/jobs"))
                .header("Authorization", "Bearer " + apiKey)
                .header("X-Operation-Id", UUID.randomUUID().toString())
                .header("Content-Type", "application/json")
                .method("POST", HttpRequest.BodyPublishers.ofString(body))
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode() + " " + response.body());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23using System.Text;

var body = "{" +
    "\"upload_id\": \"client_up_00000001\"," +
    "\"spoken_language\": \"en\"," +
    "\"max_price_usd\": \"5.00\"," +
    "\"references\": {" +
    "\"transcript\": \"client_up_transcript01\"," +
    "\"notes\": \"client_up_notes000001\"" +
    "}" +
    "}";

var url = "https://ai.inovacc.dev/v1/knowledge/jobs";
var apiKey = Environment.GetEnvironmentVariable("INOVACC_API_KEY");

using var client = new HttpClient();
using var request = new HttpRequestMessage(HttpMethod.Post, url);
request.Headers.Add("Authorization", $"Bearer {apiKey}");
request.Headers.Add("X-Operation-Id", Guid.NewGuid().ToString());
request.Content = new StringContent(body, Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);
Console.WriteLine($"{(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");

Kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.util.UUID

fun main() {
    val apiKey = System.getenv("INOVACC_API_KEY")
    val body = "{" +
        "\"upload_id\": \"client_up_00000001\"," +
        "\"spoken_language\": \"en\"," +
        "\"max_price_usd\": \"5.00\"," +
        "\"references\": {" +
        "\"transcript\": \"client_up_transcript01\"," +
        "\"notes\": \"client_up_notes000001\"" +
        "}" +
        "}"

    val request = HttpRequest.newBuilder()
        .uri(URI.create("https://ai.inovacc.dev/v1/knowledge/jobs"))
        .header("Authorization", "Bearer " + apiKey)
        .header("X-Operation-Id", UUID.randomUUID().toString())
        .header("Content-Type", "application/json")
        .method("POST", HttpRequest.BodyPublishers.ofString(body))
        .build()

    val response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())
    println("${response.statusCode()} ${response.body()}")
}

Swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import Foundation
#if canImport(FoundationNetworking)
import FoundationNetworking
#endif

let body = #"""
{
  "upload_id": "client_up_00000001",
  "spoken_language": "en",
  "max_price_usd": "5.00",
  "references": {
    "transcript": "client_up_transcript01",
    "notes": "client_up_notes000001"
  }
}
"""#

let apiKey = ProcessInfo.processInfo.environment["INOVACC_API_KEY"] ?? ""

let url = URL(string: "https://ai.inovacc.dev/v1/knowledge/jobs")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue(UUID().uuidString, forHTTPHeaderField: "X-Operation-Id")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = Data(body.utf8)

let (data, response) = try await URLSession.shared.data(for: request)
let status = (response as? HTTPURLResponse)?.statusCode ?? 0
print(status, String(decoding: data, as: UTF8.self))

Ejemplo

202

1
2
3
4
5{
  "job_id": "client_op_job_00001",
  "poll_after_seconds": 142,
  "status_url": "/v1/knowledge/jobs/client_op_job_00001"
}

400

Códigos de error: missing_operation_id invalid_operation_id invalid_body

403

Códigos de error: knowledge_disabled budget_exceeded

404

Códigos de error: upload_not_found

409

Códigos de error: operation_in_progress upload_incomplete

413

Códigos de error: request_too_large

502

Códigos de error: upstream_error

503

Códigos de error: service_unavailable