Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Credenziali sulle connessioni — una chiave per connessione, e un’unica chiave a entrambi i capi

Uno store di memoria semantica che raggiunge due modelli e presenta una chiave diversa a ciascuno, compilato in manifest Kubernetes. Legge il materiale acquisito con un modello ospitato e lo codifica con un server di embedding in esecuzione accanto a esso nel cluster. La chiave che presenta al modello ospitato viene recuperata da un secret store del cluster. Il server di embedding verifica una chiave propria, e lo store presenta quella stessa chiave — entrambi i capi la leggono da un unico parametro, quindi le due non possono essere scritte diverse.

Questo workspace non scrive alcuna entità di catalogo propria. Ogni Component, Feature e Recipe che nomina fa parte del catalogo della libreria standard; i file qui — tre Aggregates, un Manifest e tre Releases — sono tutto ciò che qualcuno scrive.

Che cosa costruisce

┌── extraction_model ──► llm a hosted model API
│ key on the connection, fetched from a secret store
memory ───┤
│
└── embedding_model ──► embeddings an embedding server that checks a key
key on the connection ═══ the server's own api_key
(both read one parameter)
istanzaComponent del catalogoche cosa è qui
memorycore/datastore/cogneeil chiamante: uno store di memoria semantica i cui due socket di modello dichiarano ciascuno uno slot credential per la chiave che presenta su quella connessione
llmcore/ai-model/openaiun modello ospitato, etichettato component.aggrega.ai/hosting: managed; raggiunto come riferimento, quindi per esso non viene eseguito nulla nel cluster
embeddingscore/ai-model/teiText Embeddings Inference nel cluster, etichettato self-hosted; richiede una chiave a ogni chiamante e la detiene nel proprio slot api_key

Tre release condividono un unico Manifest, manifest.yaml, e ciascuna ha un Aggregate proprio:

releaseAggregateche cosa mostra
release-matched.yamlaggregate-matched.yamlentrambe le connessioni scritte dallo sviluppatore, i due capi della connessione di embedding che leggono un unico parametro
release-mismatched.yamlaggregate-mismatched.yamllo stesso con i due capi che leggono due parametri: il build va a buon fine, e il controllo delle convenzioni emette un avviso
release-operator-wired.yamlaggregate-operator-wired.yamlla connessione di estrazione lasciata all’operatore: la Release la cabla e ne nomina la chiave in infra

Generare l’esempio

Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

Terminal window
aggrega scaffold --example connection-credentials

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:

Terminal window
cd connection-credentials

Build

Esegui il build di una release per esecuzione:

Terminal window
aggrega build --release release-matched.yaml --auto-pull # → dist/matched/
aggrega build --release release-mismatched.yaml --auto-pull # → dist/mismatched/
aggrega build --release release-operator-wired.yaml --auto-pull # → dist/operator-wired/

Ogni release scrive nella propria directory, quindi i tre alberi renderizzati coesistono e se ne può fare il diff l’uno con l’altro.

Una release ha bisogno del suo lockfile prima del build, e i lockfile sono generati anziché inclusi. Risolvine prima uno, oppure lascia che lo riempia il build:

Terminal window
aggrega pull --release release-matched.yaml # resolve, then build normally
aggrega build --release release-matched.yaml --auto-pull # or resolve during the build

Il workspace risolve le sue entità dal registry predefinito nominato da .aggrega-config.yaml, quindi non serve alcun flag --catalog.

Il comando pull stampa:

[… omitted: a warning that the declared-sensitive origin of llm.credential reaches the target with no per-key sensitivity marking, because its realization maps it through a valuesMapping]
Pull complete: release-matched.lock (entities=15, source_artifacts=0, external_inputs=0)

e il build, con <workspace> al posto della cartella di questo esempio:

[… omitted: the same warning about llm.credential the pull printed]
notice: LINT: Feature "core/referenced-secret" at core/referenced-secret:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 8 files written to <workspace>/dist

Le altre due release stampano le stesse righe, con ogni comando pull che nomina il proprio lockfile e ogni build che scrive otto file. La riga notice: riguarda la Feature di credenziale che usa ogni associazione qui: core/referenced-secret accetta il nome del suo segreto, origin, dai values dello sviluppatore oppure dall’infra dell’operatore, e l’avviso segnala che una foglia è dichiarata in entrambi i pilastri. Non cambia alcun verdetto né alcun byte renderizzato; Features di credenziale spiega perché la foglia si trova in entrambi.

Dove questa pagina stampa ciò che un build ha prodotto, il blocco è copiato da un’esecuzione reale — vedi Leggere l’output in queste pagine per la convenzione e il segno che usa per le righe omesse.

Con un assistente AI

Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella dell’area di lavoro non contiene ancora una cartella `connection-credentials`, chiama una volta lo strumento `scaffold` con `example` impostato a `connection-credentials` e senza `dir`: scrive l’esempio in una nuova cartella `connection-credentials`. Poi chiama lo strumento `build` una volta per ogni Release, in quest’ordine — `release-matched.yaml`, `release-mismatched.yaml`, `release-operator-wired.yaml` — ogni volta con `workspace_root` impostato a `connection-credentials`, `release` impostato a quel file, `auto_pull` impostato a true e `write` impostato a true. Dimmi quali file ha scritto ciascuna build; si trovano in `connection-credentials/dist/`.

L’albero renderizzato

dist/matched/helm/
├── embeddings-default-service.yaml
├── embeddings-headless-service.yaml
├── embeddings-statefulset.yaml
├── llm-service.yaml
├── memory--llm-zdcredential--memory-externalsecret-memory-memory-llm-credential.yaml
├── memory-default-service.yaml
├── memory-headless-service.yaml
└── memory-statefulset.yaml

Un file è stato portato da un’associazione anziché dalla Recipe propria di un componente: l’ExternalSecret che recupera la chiave che lo store presenta al modello ospitato. Il suo nome di file porta il componente che riceve l’associazione, memory, e il nome dell’associazione, llm.credential, scritto llm-zdcredential perché il punto condivide un’unica stringa con il nome proprio del file; vedi Denominare una risorsa renderizzata. Nessun file porta la chiave di embedding: si trova in un Secret che il namespace detiene già, come mostrano le sezioni seguenti.

Quale documento ha scritto che cosa

  • Il catalogo dichiara i punti di aggancio. Il Component dello store dichiara uno slot credential su ciascuno dei suoi due socket di modello; il Component del server di embedding dichiara api_key su sé stesso; ogni Recipe decide la variabile con cui viene consegnata una chiave.
  • L’Aggregate — lo sviluppatore — scrive quali modelli raggiunge lo store, la credenziale su ciascuna connessione, la chiave che il server verifica e l’unico parametro che leggono entrambi i capi della connessione di embedding.
  • Il Manifest — l’instradamento dell’operatore per questa destinazione — decide che cosa diventa ciascuna credenziale su Kubernetes: un riferimento a un Secret che il namespace detiene già per ogni associazione core/referenced-secret, tranne quella sulla connessione al modello ospitato, che viene recuperata da un secret store del cluster.
  • La Release — il documento dell’operatore per un ambiente — soddisfa i parametri, colloca il confine in un namespace e, nella release cablata dall’operatore, cabla la connessione di estrazione e nomina la chiave presentata su di essa.

Una chiave per connessione

Lo store raggiunge due modelli tramite due socket dichiarati dalla sua entità di catalogo, extraction_model ed embedding_model, e ogni socket dichiara uno slot credential. Quindi la chiave che lo store presenta si trova sulla connessione su cui viene presentata, e ogni connessione porta la propria. Da aggregate-matched.yaml:

memory:
type: core/datastore/cognee
values:
# The width of the vectors the embedding model above returns.
embedding_dimensions: 384
uses:
extraction_model:
llm:
target: llm
features:
credential: # the key presented to the hosted model
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.provider_key_entry }}"
embedding_model:
embeddings:
target: embeddings
features:
credential: # the key presented to the embedding server
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.embedding_key_secret }}"

Un’associazione scritta su una connessione diventa una delle associazioni proprie dello store, con il nome formato dall’alias della connessione, un punto e lo slot: llm.credential ed embeddings.credential. Ecco le prime due e le ultime quattro voci dell’env del container dello store, da dist/matched/helm/memory-statefulset.yaml:

- name: LLM_API_KEY
valueFrom:
secretKeyRef:
name: memory-llm.credential
key: api-key
- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key
[… omitted: the store's own settings, HTTP_PORT to EMBEDDING_DIMENSIONS]
- name: EMBEDDING_ENDPOINT
value: http://embeddings-default:8080/v1
- name: EMBEDDING_MODEL
value: BAAI/bge-small-en-v1.5
- name: LLM_ENDPOINT
value: https://api.openai.com/v1
- name: LLM_MODEL
value: gpt-4o-mini

Le prime due sono le chiavi, ciascuna dalla credenziale sulla propria connessione, sotto la variabile che la Recipe dello store assegna a quel lato — LLM_API_KEY per l’estrazione, EMBEDDING_API_KEY per l’embedding. Entrambe sono riferimenti, non valori, e il provider helm scrive le voci che legge da un Secret prima di quelle semplici. Le ultime quattro provengono dalle due connessioni: ogni modello pubblica il proprio indirizzo e il proprio nome di modello, e la Recipe dello store li legge per socket.

Il Component dello store dichiara anche uno slot di chiave su sé stesso, model_api_key. La sua Recipe legge quello slot solo per un socket lasciato non cablato, dove lo store raggiunge un provider all’indirizzo proprio del provider e non c’è alcuna connessione che porti una chiave. Qui entrambi i socket sono cablati, quindi non viene letto.

Un’unica chiave a entrambi i capi

Il server di embedding verifica una chiave. Detiene quella chiave in uno slot del proprio Component, api_key, e la sua Recipe consegna qualunque cosa riempia lo slot come API_KEY, la variabile che Text Embeddings Inference legge all’avvio. Da aggregate-matched.yaml:

embeddings:
type: core/ai-model/tei
values:
model: BAAI/bge-small-en-v1.5
features:
api_key: # the key the server verifies
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.embedding_key_secret }}"

Questa è un’associazione sul server. La chiave che presenta lo store è un’altra, sulla connessione dello store, mostrata sopra. Riempire lo slot di un capo non riempie nulla sull’altro, quindi dichiarare la chiave a entrambi i capi è il minimo anziché un duplicato. Ciò che fa delle due un’unica chiave è che entrambe leggono un solo parametro, embedding_key_secret, che l’Aggregate dichiara e la Release soddisfa:

parameters:
provider_key_entry: ai/openai-api-key
embedding_key_secret: embedding-server-key

Il Manifest vincola core/referenced-secret a k8s-existing-secret, che legge origin come il nome di un Secret che il namespace detiene già e non renderizza nulla. Quindi entrambi i capi fanno riferimento a quell’unico Secret. Nell’env del container del server, da dist/matched/helm/embeddings-statefulset.yaml:

- name: API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key

e in quello dello store, da dist/matched/helm/memory-statefulset.yaml:

- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key

Il Secret viene creato al di fuori della Release, da chi la distribuisce, quindi il materiale della chiave non passa mai per un file scritto né per un artefatto renderizzato.

Perché il server non vede mai le chiavi dei suoi chiamanti

Un’associazione su una connessione finisce soltanto sul chiamante. Le due credenziali dello store sono associazioni dello store: ciò che renderizzano si trova accanto allo store, e il container dello store vi fa riferimento. Nulla di esse raggiunge il componente a cui punta una connessione, quindi un target viene renderizzato allo stesso modo qualunque cosa portino le connessioni che lo raggiungono.

Il modello ospitato lo mostra chiaramente. Renderizza un solo file, un Service che mappa un nome interno al cluster sull’host del provider — l’intero spec di dist/matched/helm/llm-service.yaml:

spec:
type: ExternalName
externalName: api.openai.com
ports:
- port: 443

La chiave che lo store gli presenta viene recuperata accanto allo store, come mostra la sezione successiva. Il server di embedding lo mostra per confronto: la release non concordante più sotto cambia la chiave sulla connessione di embedding dello store e lascia invariata quella del server, e i tre file del server in dist/mismatched/ differiscono da quelli in dist/matched/ solo per l’etichetta aggrega.ai/aggregate-name, che nomina l’Aggregate da cui ciascuno è stato costruito.

Quindi nulla nella configurazione del server nomina una chiave detenuta da un chiamante. In fase di esecuzione una richiesta porta la chiave del chiamante e il server la confronta con quella che detiene; il chiamante, da parte sua, legge solo ciò che il server pubblica: un indirizzo e un nome di modello.

Una chiave per server

Text Embeddings Inference verifica una sola chiave. Ogni chiamante presenta la stessa chiave, un chiamante che ne presenta un’altra viene rifiutato, e il server non sa distinguere un chiamante da un altro, quindi revocare l’accesso a un chiamante significa cambiare la chiave che ogni chiamante presenta. Per quante connessioni lo raggiungano, il suo slot api_key contiene una sola chiave. Quel limite è proprio del server, e core/ai-model/vllm e core/ai-model/tgi del catalogo lo condividono. Non è un limite della connessione: un chiamante che raggiunge più server detiene una chiave per connessione, come lo store qui ne detiene due.

La chiave di una connessione da un secret store

Il Manifest vincola ogni associazione core/referenced-secret in base al suo tipo, e una di esse in base al suo nome. Da manifest.yaml:

features:
# One realization for every core/referenced-secret attachment: the Secret
# already exists in the namespace, and origin is its name.
type:
core/referenced-secret:1.0.0: helm/k8s-existing-secret:1.0.0
# One attachment bound differently, by its name. An attachment written on
# a connection is named for the connection's alias, a dot and the slot,
# so the memory store's credential on its llm connection is
# llm.credential. That key is fetched from the store, and origin is the
# store entry to fetch.
name:
llm.credential: helm/k8s-external-secret:1.0.0

k8s-external-secret legge origin come la voce del secret store da recuperare. L’origin della connessione è il parametro provider_key_entry, soddisfatto come ai/openai-api-key, quindi l’associazione renderizza un ExternalSecret che un operator di secret store nel cluster riconcilia in un Secret. L’intero spec di dist/matched/helm/memory--llm-zdcredential--memory-externalsecret-memory-memory-llm-credential.yaml:

spec:
refreshInterval: "1h"
secretStoreRef:
name: platform-secret-store
kind: ClusterSecretStore
target:
name: memory-llm.credential
creationPolicy: Owner
data:
- secretKey: api-key
remoteRef:
key: "ai/openai-api-key"

Il Secret che riempie, memory-llm.credential, prende il nome dallo store e dalla connessione, ed è il nome a cui fa riferimento più sopra LLM_API_KEY dello store. La realizzazione legge da un ClusterSecretStore chiamato platform-secret-store.

Ciò che porta un parametro discende dalla realizzazione che lo legge: una voce del secret store per la chiave del modello ospitato, il nome di un Secret per la chiave di embedding. La chiave di una connessione riceve una realizzazione propria mentre ogni altra associazione dello stesso tipo mantiene quella del tipo.

Dove i due capi risolvono un segreto

Una piattaforma di destinazione risolve un segreto per riferimento all’interno di un ambito dei segreti: il confine entro cui una risorsa può nominarne un’altra. Dove entrambi i capi di una connessione si trovano in un unico ambito, entrambi fanno riferimento a un’unica risorsa di segreto. Dove si trovano in ambiti diversi, ciascun capo detiene una risorsa di segreto propria, realizzata a partire dalla stessa voce del secret store. Il Manifest sceglie la realizzazione di ciascun capo — per tipo di Feature, per ogni associazione di quel tipo, oppure per una singola associazione in base al suo nome.

Ogni destinazione traccia l’ambito nei propri termini. Su Kubernetes, per cui questo workspace esegue il build, è il namespace: un carico di lavoro fa riferimento a un Secret solo nel proprio. Ogni release qui colloca il suo unico confine in un unico namespace, aggrega.ai/namespace: memory, e ogni documento renderizzato lo riporta — l’intestazione di entrambi gli StatefulSet:

dist/matched/helm/memory-statefulset.yaml
metadata:
name: memory
namespace: memory
# dist/matched/helm/embeddings-statefulset.yaml
metadata:
name: embeddings
namespace: memory

Quindi entrambi i capi fanno riferimento all’unico Secret visto sopra. Con il server di embedding in un namespace proprio, il Manifest vincola le credenziali di entrambi i capi per nome — api_key ed embeddings.credential — a k8s-external-secret, la Release soddisfa il parametro con la voce del secret store, e ciascun capo detiene un ExternalSecret nel proprio namespace, ed entrambi recuperano quell’unica voce. Lo store raggiunge allora il server attraverso i namespace, come descrive cross-boundary-networking. Sulle altre destinazioni l’ambito è un progetto Compose, una configurazione radice di Terraform e uno stack CloudFormation; il Modello delle credenziali li descrive ciascuno.

L’operatore cabla una connessione

aggregate-operator-wired.yaml scrive la connessione di embedding e lascia libero il socket extraction_model dello store: l’entità di catalogo dello store lo dichiara, e lo sviluppatore lo lascia all’operatore. La Release lo cabla al modello ospitato che l’Aggregate dichiara. Da release-operator-wired.yaml:

memory:
uses:
# A connection the Aggregate does not write, into a socket the
# store's catalog entity declares, to a component the Aggregate
# declares. A Release writes no values, so the credential on it
# names its secret in infra.
extraction_model:
llm:
target: llm
features:
credential:
type: core/referenced-secret
infra:
origin: ai/openai-api-key

Una Release può cablare una connessione in un socket che l’entità di catalogo dichiara e che l’Aggregate lascia libero, verso un componente che l’Aggregate dichiara. Non aggiunge alcun componente, e non cambia mai la destinazione di una connessione scritta dall’Aggregate. Non scrive alcun values, quindi la credenziale su quella connessione nomina il suo segreto in infra: core/referenced-secret prende origin dai values dello sviluppatore oppure dall’infra dell’operatore, esattamente uno dei due, e il build si arresta su un’associazione che li porta entrambi o nessuno dei due.

L’associazione si chiama llm.credential esattamente come nella release concordante, quindi il livello dei nomi del Manifest la vincola allo stesso modo. Oltre all’etichetta che nomina l’Aggregate, due righe differiscono tra dist/operator-wired/ e dist/matched/. Il data dell’ExternalSecret:

data:
- secretKey: value
remoteRef:
key: "ai/openai-api-key"

e il riferimento dello store al Secret che riempie, in dist/operator-wired/helm/memory-statefulset.yaml:

- name: LLM_API_KEY
valueFrom:
secretKeyRef:
name: memory-llm.credential
key: value

La chiave dei dati è value anziché api-key perché key è una foglia dei values, che solo l’Aggregate scrive, quindi un’associazione fatta dalla sola Release legge il valore predefinito della Feature. La realizzazione pubblica quella chiave e lo store la legge da ciò che è stato pubblicato, quindi i due concordano comunque.

Il modello ospitato è etichettato managed, quindi una connessione che lo raggiunge porta una credenziale oppure dichiara nei propri values che il modello non ne richiede alcuna, unauthenticated: true. Questo vale qualunque documento abbia scritto la connessione. Rimuovi il blocco features: dalla connessione della Release e il build si arresta. L’arresto è E0033, un’asserzione fallita del Component dello store, e il suo messaggio termina con la frase propria della regola: the extraction_model connection llm of “memory” reaches “llm”, whose component.aggrega.ai/hosting label is managed, with no credential: attach one under credential on that connection, or set unauthenticated: true in its values (la connessione extraction_model llm di «memory» raggiunge «llm», la cui etichetta component.aggrega.ai/hosting è managed, senza alcuna credenziale: associane una sotto credential su quella connessione, oppure imposta unauthenticated: true nei suoi values).

Quando i due capi non concordano

aggregate-mismatched.yaml assegna alla chiave del server e alla chiave dello store due parametri:

parameters:
provider_key_entry:
type: string
description: >
The store entry holding the key the memory store presents to the hosted
model provider.
embedding_key_secret:
type: string
description: The Secret holding the key the embedding server verifies.
# The fault: a second parameter for what is meant to be the same key.
memory_embedding_key_secret:
type: string
description: The Secret holding the key the memory store presents to the embedding server.

L’api_key del server legge embedding_key_secret e la connessione dello store legge memory_embedding_key_secret, che la Release soddisfa con due Secret diversi. Il build va a buon fine e scrive otto file: il compilatore valuta ogni associazione che riceve e non confronta nulla tra i due capi. Il server fa ancora riferimento a embedding-server-key, e lo store ora ne presenta un altro, da dist/mismatched/helm/memory-statefulset.yaml:

- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-client-key
key: api-key

Una volta distribuito, il server accetta le richieste dello store solo se quei due Secret contengono per caso la stessa chiave.

Il controllo delle convenzioni di pubblicazione di una Release è il punto in cui questo viene individuato:

Terminal window
aggrega lint --release release-mismatched.yaml
release-mismatched.yaml:
warn: E0329 connection-credential-matches-target-key: connection "embeddings" on socket "embedding_model" of component "memory" carries a credential in its credential slot and its target "embeddings" holds a key in its api_key slot, but the two ends write their secret's locator differently, so they may name different secrets and the target would refuse the key this caller presents. The locators are compared as written, and neither is shown here. Reading one parameter at both ends keeps them one key; that agreement is the standard-catalog convention, and the build does not check it.
conventions checked: 10 entities, 1 advisory finding(s)

Lo stesso controllo sulla release concordante non segnala nulla:

Terminal window
aggrega lint --release release-matched.yaml
conventions checked: 10 entities, 0 advisory finding(s)

e nemmeno su quella cablata dall’operatore.

La regola trova i due capi tramite i nomi che dà loro il catalogo standard — l’api_key della destinazione e la credential della connessione — e confronta l’origin che scrive ciascun capo, così come è scritto: due capi che leggono un unico parametro risultano uguali, e nulla viene risolto. Non cita mai nessuno dei due, poiché ciò che vi è scritto può essere il segreto stesso. Non giudica una destinazione etichettata managed, la cui api_key, dove ne dichiara una, è la chiave presentata al suo fornitore anziché una che presentano i suoi chiamanti; quindi la connessione a llm non produce alcun rilievo in nessuna delle tre release. Il rilievo è un’indicazione: aggrega lint termina con 0, e un workspace i cui due capi differiscono deliberatamente se ne esclude con allow_connection_credential_mismatches. Un editor che pone al daemon la stessa domanda, aggrega/lint con il nome della Release, riceve lo stesso rilievo sotto il codice connection-credential-matches-target-key e il codice breve E0329. La regola e ciò che legge sono descritti in Le regole di disciplina.

Determinismo

Tutte e tre le release eseguono il build con --verify-determinism, che renderizza ogni nodo due volte e confronta i byte emessi:

Terminal window
aggrega build --release release-matched.yaml --verify-determinism

Ricostruire una qualsiasi delle tre da un albero pulito ne riproduce l’output renderizzato byte per byte.

Adattarlo

  • Aggiungi un secondo chiamante del server di embedding. Anche la credenziale della sua connessione legge embedding_key_secret. Il server detiene una sola chiave per tutti i chiamanti, quindi il secondo chiamante presenta la stessa chiave.
  • Recupera anche la chiave di embedding dal secret store. Vincola api_key ed embeddings.credential per nome a k8s-external-secret e soddisfa embedding_key_secret con una voce del secret store anziché con il nome di un Secret. Entrambi i capi cambiano insieme perché entrambi leggono il parametro.
  • Raggiungi un modello che non verifica alcuna chiave. Lascia la credenziale fuori dalla connessione. Dove la destinazione è etichettata managed, dichiaralo sulla connessione con unauthenticated: true nei suoi values.

Per condividere una chiave tra le connessioni di più chiamanti, vedi model-api-key-sharing. Per un router che detiene le chiavi dei provider per conto dei suoi chiamanti, vedi ai-agent-and-model-router. Il modello alla base di tutto ciò è il Modello delle credenziali.