5 concetti fondamentali sull'IA

Prima di iniziare a usare EasyClaw, dedica 5 minuti a imparare questi concetti: ti aiuteranno a comprendere davvero come funziona l'IA, invece di inserire istruzioni alla cieca.
Non devi essere un ingegnere, ma devi sapere: perché l'IA può fare certe cose, come renderla più precisa e quando potrebbe fallire.

1. Agente (Agente intelligente)

Adesso chiariamo come opera. Puoi immaginare il processo di lavoro dell'agente come un ciclo ripetuto: Comprendi il compito → Prepara un piano → Chiama strumenti → Esegui l'azione → Verifica il risultato → Adatta → Riferisci.

1) Comprendere il compito:
L'agente determinerà innanzitutto quale problema stai cercando di risolvere, come si configura il successo e se ci sono vincoli (ad esempio, formato, tono, tempistiche, cosa non dovrebbe fare). Se le informazioni sono insufficienti, potrebbe farti domande per prime, oppure formulare ipotesi necessarie e spiegarle.

2) Preparare un piano (scomposizione in passi):
I compiti grandi spesso devono essere suddivisi in passi più piccoli. Ad esempio, "organizzare la posta in arrivo" potrebbe essere scomposto in: Scansionare le email → Identificare i tipi (notifiche/fatture/clienti/varie) → Valutare la priorità → Archiviare → Preparare bozze di risposta (se necessario) → Riepilogare l'elenco. Questo passo determina "cosa fare prima, cosa fare dopo".

3) Chiamare strumenti/capacità:
Questo è anche il punto chiave per cui un agente può "portare a termine le cose". Senza strumenti, può rimanere solo a livello di consigli testuali; con gli strumenti, può realmente eseguire azioni, come: leggere file, cercare informazioni, inviare messaggi, accedere a sistemi aziendali, generare documenti, ecc. Vedrai l'agente "connettersi con il mondo esterno", non solo generare una frase.

4) Eseguire e registrare:
Nei momenti opportuni, l'agente attiverà effettivamente le operazioni (ad esempio, chiamare un'API di servizio, completare un'attività di elaborazione dati, generare contenuti utilizzabili). Allo stesso tempo, registra "quale passo ho completato", rendendo facile continuare o tornare indietro per correggere in seguito.

5) Verifica e correzione degli errori:
L'agente non mirerà solo a "sembrare completato"; verificherà anche se il risultato soddisfa i requisiti. Ad esempio: nell'output mancano campi chiave, viola i tuoi requisiti di formato, ci sono errori evidenti o incertezze? Se non è soddisfatto, ripianificherà il passo successivo e continuerà a iterare.

6) Riferire i risultati e i passi successivi:
Infine, l'agente riassumerà i contenuti completati, i risultati importanti e gli elementi che necessitano della tua conferma. Potrai vedere chiaramente: cosa ha fatto, cosa è stato completato, cosa è ancora in corso.

2. Competenza (Capacità/Abilità)

Nel ciclo dell'agente, il passo "chiamare strumenti/capacità" appare frequentemente, e ciò che viene chiamato è solitamente una competenza. Puoi pensarlo come: l'agente è come un cervello, le competenze sono come mani, piedi e una cassetta degli attrezzi.

Per approfondire, spieghiamo a fondo "come funziona una competenza nel ciclo dell'agente":

1) L'agente determina quale competenza è necessaria
Quando il compito entra nella fase di esecuzione, l'agente analizzerà quali capacità sono necessarie per il passo corrente. Ad esempio, "trovare le registrazioni storiche delle comunicazioni di un cliente" richiede una competenza di tipo "recuperare/leggere"; "preparare una bozza di email di follow-up" richiede una competenza di tipo "generare testo/usare modello"; "sincronizzare il compito nel sistema di cose da fare" richiede una competenza di tipo "scrivere/aggiornare".

2) L'agente inserisce i parametri nella competenza (input)
Le competenze di solito richiedono un formato di input specifico, come: parole chiave, intervallo di tempo, ID cliente, pubblico di destinazione, stile di output, ecc. L'agente estrarrà il contesto e lo organizzerà nei parametri richiesti dalla competenza.
Questo passo determina se l'esecuzione è accurata: se l'input è sbagliato, è probabile che l'output sia fuori strada.

3) La competenza esegue e restituisce il risultato (output)
Dopo l'esecuzione, la competenza restituisce risultati strutturati o semi-strutturati, come: elenchi di elementi recuperati, risultati di calcoli, testo del documento generato, codici di stato dell'API, ecc. Questi risultati possono essere riletti dall'agente per le decisioni successive.

4) L'agente convalida l'output e procede al passo successivo (ciclo chiuso)
Il completamento della competenza non è il punto finale; l'agente verificherà anche: se il risultato soddisfa i vincoli, se mancano informazioni, se è necessaria una seconda generazione o correzione. Se non è soddisfatto, potrebbe chiamare un'altra competenza (ad es., "ricerca supplementare", "riscrivere contenuto", "formattare output") e iterare di nuovo. Questo è il "ciclo chiuso cooperativo" di competenza e agente.

Esempio: chiedi all'agente di "scrivere un'email di follow-up ai potenziali clienti e creare un elemento nell'elenco delle cose da fare".
Questo di solito concatena più competenze insieme, formando una catena di azioni completa:

1) Competenza di recupero informazioni cliente: input ID/nome cliente, output nome, azienda, punti chiave dell'ultima comunicazione;
2) Competenza di estrazione/riepilogo informazioni: input registrazioni comunicazioni, output punti critici chiave e elementi realizzati;
3) Competenza di generazione email: input tono (professionale/amichevole), modello (follow-up/chiusura), punti chiave, output corpo dell'email;
4) Competenza di generazione cose da fare: input contenuto email e suggerimenti di azione, output elementi da fare (responsabile, scadenza, passi);
5) Competenza di scrittura su calendario/sistema cose da fare: input dati strutturati delle cose da fare, output stato di creazione riuscita o link.

Noterai: l'agente sembra "capire il lavoro di vendita", ma dietro ci sono moduli di competenza che inseriscono capacità reali in un flusso di lavoro. L'agente è responsabile di usare queste capacità nell'ordine giusto.

Continua a usare il "ciclo operativo" dell'agente per comprendere la competenza: l'agente è responsabile di pensare e pianificare, la competenza è responsabile di eseguire passi concreti. Quando l'agente scopre che un compito ha bisogno di una certa capacità, selezionerà la competenza appropriata, inserirà i parametri necessari, aspetterà che restituisca risultati, quindi riporterà i risultati nel ciclo per la convalida, il completamento o la pianificazione del passo successivo.

Esempio: chiedi all'agente di "scrivere un'email di follow-up a un cliente e generare un elemento nell'elenco delle cose da fare".
Potrebbe chiamare diverse competenze:
1) Recuperare informazioni cliente (ottenere nome, punti dell'ultima comunicazione);
2) Generare bozza email (output in base a tono/lunghezza/modello);
3) Generare elenco cose da fare (suddividere i passi successivi in elementi).
Quando queste competenze sono messe insieme, formano un comportamento dell'agente che "sembra molto capace".

3. Prompt (Istruzione)

Noterai che il prompt e i due concetti precedenti (agente / competenza) sono due facce della stessa logica operativa: l'agente ha bisogno del prompt per decidere come procedere, la competenza ha bisogno del prompt per decidere cosa inserire e come verificare.

Il "ciclo di lavoro dell'agente" può essere inteso come:
Comprendi il compito → Prepara un piano → Decidi di chiamare la competenza → La competenza esegue → Verifica il risultato → Continua ad adattare → Riferisci.
E il ruolo del prompt è dare regole a ogni passo, evitando che devii, tiri a indovinare o formi un ciclo chiuso.

1) Il prompt definisce innanzitutto "obiettivo e criteri di successo" (perché farlo)
Questo passo determina le "regole di punteggio" dell'agente. Il prompt deve dirgli: qual è esattamente il problema che stai risolvendo, e quale risultato conta come completamento.
Ad esempio: non "aiutami a scrivere un'email", ma "l'email deve includere quali paragrafi, quale tono, quale intervallo di lunghezza, e terminare con un elemento dell'elenco cose da fare".

Senza criteri di successo nel prompt, l'agente può solo produrre un output che "sembra più o meno giusto", rendendo la qualità difficile da verificare.

2) Il prompt fornisce "condizioni di attivazione e vincoli" (quando fare cosa)
Un prompt che può produrre risultati di solito chiarisce: quando chiamare una competenza, quando fare domande.
Ad esempio: se mancano il nome del cliente o la data, deve chiedere prima invece di inserire di default "un nome/data a caso".

Ciò equivale a ridurre l'incertezza: più chiari sono i vincoli, più stabile è l'agente.

3) Il prompt descrive "quali competenze sono necessarie e i contratti di input/output per ciascuna" (quali strumenti usare)
Il prompt deve chiarire:
Quale competenza chiamare, quali campi di input richiede, da dove provengono i campi di input, quali sono i requisiti di formato; e allo stesso tempo chiarire: in quale struttura deve essere restituito l'output della competenza (ad es., campi JSON, elenchi, tabelle, struttura fissa dei paragrafi, ecc.).

Questo passo è la chiave per rendere il prompt veramente "ingegnerizzato": trasformare "come fare il passo successivo" in "chiamata di capacità richiamabile".

4) Il prompt richiede "verifica e gestione dei fallimenti" (come giudicare se è fatto bene)
Generare risultati non è sufficiente; il prompt deve specificare regole di verifica e strategie di fallimento. Approcci comuni includono:
- Chiamata alla competenza fallita/restituisce risultato vuoto: diagnosticare prima la causa (errore di parametro/permesso/rete/dati mancanti) poi riprovare o degradare;
- Output mancante di campi chiave: deve completare o chiedere all'utente, non sono ammesse congetture;
- Formato non corrispondente: attivare "competenza di formattazione/competenza di riordinamento/rigenerare".

Questo impedisce all'agente di rimanere bloccato in un ciclo di "output ripetuti ma non convergenti".

5) Il prompt definisce il "formato dell'output finale" (chi userà l'output)
Infine, il prompt deve specificare come vengono presentati i risultati: quali campi devono essere restituiti, quali sono i nomi dei campi, se sono necessari risultati strutturati, se sono necessarie informazioni tracciabili (ad es., "se la competenza è stata chiamata, quale competenza è stata chiamata, quali erano gli input/output chiave").

4. Memoria (Memoria a lungo termine) / MEMORY.md

Ad esempio, dici all'agente: "Preferisco risposte concise in italiano, usa Python per il codice".
Se questa preferenza viene scritta nella Memoria in un formato adatto, allora quando l'agente gestirà tipi di compiti simili in futuro, seguirà queste regole per impostazione predefinita; non dovrai sottolinearlo ripetutamente, ed è molto meno probabile incontrare problemi di "stile di risposta incoerente ogni volta".

Per garantire che la Memoria sia veramente "utilizzabile", deve soddisfare gli standard dei tre concetti precedenti: attivazione stabile, input chiaro, output verificabile. In altre parole, il contenuto scritto nella Memoria dovrebbe guidare chiaramente come l'agente dovrebbe procedere successivamente, non essere una vaga espressione emotiva.

Si consiglia di scrivere la Memoria in questo stile "checklist di regole":

• Preferenze di stile di scrittura: ad es., "italiano conciso", "prima le conclusioni", "non più di 3 frasi per paragrafo"
• Requisiti di formato: ad es., "Python per il codice", "l'output della tabella include i campi A/B/C", "formato data AAAA-MM-GG"
• SOP decisionali: ad es., "chiedi se le informazioni sono insufficienti, non indovinare; fornisci alternative con etichette di rischio"
• Contesto a lungo termine: ad es., "il mio team è di consegna B2B", "gli strumenti comuni sono XX (ove applicabile)"

Punti chiave sulla Memoria:

1) La Memoria memorizza la configurazione a lungo termine (perché esiste)
La differenza principale tra Memoria e Prompt è: il Prompt gestisce questo compito specifico, mentre la Memoria gestisce "tutti i compiti futuri". Memorizzando preferenze e SOP nella Memoria, l'agente può applicare coerentemente queste regole senza che tu debba ripeterle.

Ad esempio, se scrivi "la lingua di output predefinita è l'italiano" nella Memoria, allora in tutti i compiti futuri, l'agente darà automaticamente la priorità a rispondere in italiano.

2) Quando l'agente usa la Memoria? (Meccanismo di caricamento)
In genere, la Memoria viene caricata per prima quando l'agente avvia una nuova sessione o conversazione. L'agente legge MEMORY.md, estrae le regole/preferenze, e poi le tratta come parte del contesto di sistema per questa esecuzione, analogamente all'aggiunta di istruzioni di sistema aggiuntive.

Questo è diverso dal Prompt a metà conversazione: la Memoria non cambia durante la conversazione, è la "linea di base stabile" per tutte le esecuzioni successive.

3) Cosa NON dovrebbe andare nella Memoria (impostazione dei confini)
La Memoria dovrebbe contenere: abitudini di lavoro stabili, preferenze di formato, SOP a lungo termine, vincoli ricorrenti.
La Memoria NON dovrebbe contenere: compiti una tantum, dati temporanei, informazioni specifiche della sessione, segreti personali.

Mescolarli rende la Memoria disordinata e l'agente perde la capacità di distinguere tra "ciò che è permanente" e "ciò che è temporaneo".

4) Come strutturare la Memoria per la massima efficacia
Una buona Memoria dovrebbe essere organizzata per categoria:

• Stile di comunicazione: "Rispondi sempre in italiano conciso", "prima la struttura, poi i dettagli", ecc.
• Impostazioni tecniche predefinite: "usa Python come linguaggio principale", "usa JSON per dati strutturati", ecc.
• Regole decisionali: "quando sei incerto, chiedi invece di indovinare", "fornisci sempre una valutazione del rischio", ecc.
• Contesto e background: "lavoro in B2B SaaS", "la dimensione del team è 5", ecc.
• Informazioni su strumenti e integrazioni: "il CRM tipico è Salesforce", "il sistema di log è Datadog", ecc.

In questo modo, quando l'agente legge la Memoria, può trovare rapidamente le regole pertinenti per il contesto attuale.

5) Manutenzione della Memoria (mantenerla aggiornata)
La Memoria non è "scrivi una volta, usa per sempre". Man mano che il tuo stile di lavoro evolve o le regole cambiano, dovresti periodicamente rivedere e aggiornare la Memoria per mantenerla allineata con la pratica attuale.

Una buona pratica: revisiona la Memoria trimestralmente, rimuovi elementi obsoleti, aggiungi nuovi modelli consolidati. Questo mantiene la Memoria snella ed efficace.

Le mie preferenze di lavoro e SOP

Stile di comunicazione
  Lingua: italiano (conciso, prima le conclusioni)
  Formato: punti elenco per elencare, sezioni strutturate per informazioni complesse
  Tono: professionale ma accessibile

Impostazioni tecniche predefinite
  Linguaggio principale: Python
  Formato dati: JSON
  Formato data: AAAA-MM-GG
  Fuso orario: UTC+8

Regole decisionali
  Quando le informazioni sono insufficienti: fai domande chiarificatrici, non dare per scontato
  Fornisci alternative con analisi rischi/benefici
  Includi un ragionamento tracciabile nelle decisioni complesse

Contesto
  Team: B2B SaaS, 5 persone
  CRM principale: Salesforce
  Strumenti principali: Python, PostgreSQL, Slack

SOP di processo
  Revisione del codice sempre richiesta prima del deployment
  La documentazione deve essere aggiornata quando l'API cambia
  Stand-up quotidiano alle 10:00 UTC+8
      

5. Anima (Valori fondamentali e comportamento) / SOUL.md

Se la Memoria è "ciò che è stato ricordato", allora l'Anima è "che tipo di IA diventare". Ad esempio: rispondi solo a domande relative al prodotto; le operazioni finanziarie richiedono una doppia conferma; non richiedere mai password o credenziali sensibili; per questioni legali/mediche, è necessario fornire dichiarazioni di non responsabilità e indirizzare verso canali professionali, ecc.

Si consiglia di scrivere l'Anima come una "checklist di regole eseguibili", coprendo le seguenti categorie:

• Cosa è consentito: L'ambito di lavoro dell'agente e i confini del dominio (ad es., gestire solo richieste sui prodotti/processi interni).
• Cosa è vietato: Rifiuti espliciti e netti per comportamenti ad alto rischio (ad es., richiedere password/chiavi; promettere risultati incerti; aggirare i permessi).
• Azioni che richiedono conferma: Regole per trasferimenti, rimborsi, contratti, modifiche ai permessi che devono essere doppiamente confermati o approvati.
• Stile e tono dell'output: ad es., deve essere educato, nessun attacco personale, nessun linguaggio minaccioso.
• Come gestire i confini: Quando non è in grado di completare, fornisci alternative (ad es., registra e scala a un umano/suggerisci di consultare specialisti).

Differenze chiave tra Anima, Memoria e Prompt:

1) L'Anima definisce "Che tipo di agente sei" (Identità e guardrail)
L'Anima risponde alla domanda più profonda: Cosa mi è permesso essere e fare?
Questo include:
- Ambito di lavoro: Di quali domini/compiti sono responsabile?
- Guardrail rigidi: Cosa non devo assolutamente mai fare (sicurezza, conformità, etica)?
- Flussi di approvazione: Per quali azioni devo richiedere conferma?
- Percorsi di escalation: Quando non posso aiutare, dove instrado?

L'Anima è la linea "da non oltrepassare". Viene applicata ad ogni esecuzione, indipendentemente da come gli utenti cerchino di manipolare.

2) Anima vs. Sicurezza: Perché l'Anima è importante per il deployment
Un'Anima ben configurata può prevenire molti vettori di attacco comuni:
- Iniezione di prompt: Se l'Anima dice "verifica sempre le richieste ad alto rischio", anche se un prompt dice "ignora questa regola", l'agente dovrebbe rifiutare.
- Ingegneria sociale: Se l'Anima dice "non fornire mai credenziali", non importa quanto l'utente chieda astutamente, l'agente dovrebbe rifiutare.
- Deriva dell'ambito: Se l'Anima definisce il confine del dominio dell'agente, non cercherà di gestire richieste fuori ambito tirando a indovinare.

Questo rende l'Anima fondamentale per un deployment sicuro.

3) Come l'Anima si integra con il ciclo decisionale dell'agente
Pensa al ciclo di esecuzione dell'agente in questo modo:
Passo 1: Leggi Anima → Quali sono i miei confini?
Passo 2: Leggi Memoria → Quali sono le mie preferenze di lavoro?
Passo 3: Ricevi Prompt → Qual è questo compito specifico?
Passo 4: Pianifica esecuzione → Entro i confini, raggiungi l'obiettivo
Passo 5: Verifica conformità → Sono rimasto entro l'Anima?
Passo 6: Esegui / Escala

Nota che l'Anima viene controllata prima e dopo l'esecuzione. È il ciclo esterno.

Concetti avanzati (Opzionali)

I tre concetti seguenti ti aiuteranno a "capire davvero l'automazione". Non sono conoscenze completamente nuove, ma portano piuttosto i concetti precedenti di Agente / Competenza / Memoria / Anima / Prompt al livello pratico di "esecuzione reale, collegamento e integrazione stabile". I principianti possono saltarli per ora; quando inizierai a costruire processi multi-passo, integrare servizi esterni o eseguire il debug di problemi di flusso di dati, tornare qui farà risparmiare tempo significativo.

🔀 1) Flusso di lavoro (Esecuzione di processi multi-passo)

Un Flusso di lavoro può essere inteso come un percorso di esecuzione riutilizzabile: collegando più passi in sequenza per consentire al sistema di raggiungere un obiettivo in modo sistematico. Se l'Agente è "un collega che sa pensare ed eseguire", allora il Flusso di lavoro è "la coda di compiti e il metodo di collegamento che impostiamo per quel collega". Risolve il problema: quando un compito non può essere completato in una frase, come eseguiamo in modo affidabile più passi come una catena collegata?

Un tipico Flusso di lavoro di solito contiene questi elementi (puoi usare questo framework per comprendere le capacità multi-passo di EasyClaw):

• Elenco dei passi: Cosa fare al passo 1, passo 2, ecc. Ogni passo dovrebbe avere confini e responsabilità chiari.
• Input e Output: Ogni passo dovrebbe produrre risultati strutturati che il passo successivo può utilizzare, non solo "descrizioni testuali".
• Condizioni e diramazioni: Ad esempio, "se manca un campo critico, chiedi prima o recupera altri dati", altrimenti procedi al passo successivo.
• Convalida e gestione degli errori: Ad esempio, "se l'analisi fallisce, riprova o ricadi su un approccio alternativo".
• Output di riepilogo: Fornisci il risultato finale in un formato utilizzabile (checklist, report, elenco di compiti, contenuto della notifica, ecc.).

Come si allinea il Flusso di lavoro con i concetti precedenti? Una frase li collega:
L'Agente gestisce il processo decisionale e la pianificazione, la Competenza gestisce l'esecuzione concreta, Memoria/Anima gestiscono regole e confini a lungo termine, il Prompt gli dice "come farlo", e il Flusso di lavoro collega questi passi in sequenza come una catena.

Esempio: devi completare "escala il reclamo dell'utente a ticket e notifica il responsabile". Un Flusso di lavoro ragionevole potrebbe essere simile a questo:

1. Raccogli input: Raccogli il contenuto del reclamo, le informazioni sull'utente, la tempistica dal modulo/messaggio.
2. Estrazione delle informazioni: Usa l'Agente per strutturare i punti chiave del reclamo (ad es., tipo di problema, ambito di impatto, timestamp critici).
3. Giudizio sulle regole: In base all'Anima/regole, determina se è ad alta priorità, necessita di escalation o richiede prima ulteriori informazioni.
4. Chiama la Competenza di creazione ticket: Inserisci i campi strutturati nell'API del sistema di ticket, genera il numero del ticket.
5. Chiama la Competenza di notifica: Invia il numero del ticket e il riepilogo chiave al responsabile (Feishu/email/IM).
6. Convalida del risultato: Conferma che la creazione del ticket abbia restituito lo stato di successo, la notifica sia stata inviata.
7. Feedback di riepilogo: Output all'utente o all'amministratore "Ticket creato + link/numero + passi successivi".

Noterai: il Flusso di lavoro non risolve "come scrivere una spiegazione", ma piuttosto "come concatenare in modo affidabile più chiamate di strumenti e passi di convalida". Quando inizi a gestire processi complessi (specialmente multi-sistema: IM + ticket + database), il Flusso di lavoro diventa la capacità su cui farai più affidamento.

📦 2) JSON (Formato di scambio dati)

JSON è il formato standard per passare dati tra l'Agente e gli strumenti/API esterni. Nell'automazione multi-passo, il ruolo di JSON è critico: rende "il passo successivo può ottenere dati corretti" una domanda verificabile, non "possiamo capire intuitivamente una frase in linguaggio naturale".

Puoi pensare a JSON come a un "contenitore di dati strutturati" all'interno del sistema. Invece di frasi libere, contiene campi e tipi espliciti, come: titolo del ticket, ID utente, priorità, scadenza, contenuto della notifica, ecc.

Nel flusso di lavoro di EasyClaw, JSON appare tipicamente in questi posti:

• Input e Output delle Competenze: Le competenze spesso necessitano di campi specifici come input, restituendo risultati strutturati per il processo decisionale dell'agente.
• Parametri di chiamata API: Ad esempio, quando si chiama l'API di Feishu, i parametri devono essere organizzati in JSON.
• Trasferimento dati tra i passi: L'output JSON di un passo viene letto dal passo successivo.

Perché molti problemi che sembrano "l'Agente non può farlo" in realtà derivano da JSON? Casi comuni includono:

• Mancata corrispondenza del nome del campo: L'input previsto è user_id, ma l'input effettivo è userId.
• Campi mancanti: Il campo richiesto è mancante, l'API restituisce errore.
• Mancata corrispondenza del tipo: La data dovrebbe essere una stringa ma è passata come numero, o dovrebbe essere un array ma è passata come testo.
• Errore di formato JSON: Virgolette mancanti, parentesi mancanti, virgole finali, l'analisi fallisce.

Pertanto, il miglior ordine di risoluzione dei problemi per i problemi di integrazione è di solito:
Controlla prima JSON, poi il Prompt, poi la logica di ragionamento dell'Agente.
Perché JSON è la base del "se funzionerà".

🔑 3) Chiave API (Credenziale di accesso)

Una Chiave API è la credenziale di autenticazione quando si accede a modelli IA o servizi di terze parti. Senza la Chiave API corretta, il sistema in genere non può chiamare il modello o servizio corrispondente; anche se l'Agente ragiona perfettamente, l'esecuzione rimane impossibile.

Negli scenari di EasyClaw, devi distinguere due casi:

• Utilizzo delle capacità/crediti ufficiali per impostazione predefinita: I principianti in genere non hanno bisogno della propria Chiave, poiché la piattaforma ha già impostato l'accesso per te.
• Integrazione di modelli personalizzati/servizi personalizzati: Devi inserire la Chiave API nella posizione appropriata e indirizzare l'Agente/Competenza a quel modello.

La Chiave API non riguarda solo "può o non può usarla", ma influisce anche su "quali capacità, costo e stabilità":

• Selezione del modello: Chiavi/modelli diversi possono fornire diversa qualità di ragionamento, velocità e prestazioni del formato di output.
• Controllo dei costi: Alcune piattaforme addebitano in base all'utilizzo; l'account/quota della Chiave influisce sul budget disponibile.
• Confini di autorizzazione: Alcune Chiavi di servizio possono consentire solo chiamate API limitate, causando il fallimento dell'esecuzione di specifiche Competenze.

Risoluzione dei problemi comune per "chiamata della Competenza fallita":
Conferma se la Chiave è inserita correttamente, se la Chiave è scaduta/quota insufficiente, se quella Chiave ha i permessi di chiamata.
Se l'API restituisce un errore di autenticazione (401/403), sospetta prima la configurazione della Chiave API.

Quando devi studiare seriamente questi concetti? (Riferimento rapido)

• Stai costruendo automazione multi-passo: Il Flusso di lavoro determina se la catena può funzionare stabilmente.
• Stai integrando Feishu/sistemi aziendali/API esterne: JSON determina se i dati vengono trasferiti correttamente e possono essere analizzati.
• Stai integrando il tuo modello o servizio personalizzato: La Chiave API determina se puoi chiamare la capacità corrispondente.
• Stai eseguendo il debug di "sa spiegare ma non può eseguire" o "l'esecuzione fallisce senza indizi": Di solito la risoluzione dei problemi nell'ordine: concatenazione del Flusso di lavoro, struttura JSON, permessi della Chiave API è la più veloce.