update

pages/introduction/_meta.it.json

@@ -0,0 +1,8 @@
+{
+    "settings": "Impostazioni LLM",
+    "basics": "I fondamentali del Prompt",
+    "elements": "Elementi di un Prompt",
+    "tips": "Suggermenti generali per la progettazione di Prompt",
+    "examples": "Esempi di Prompt"
+}
+  

pages/introduction/basics.it.mdx

@@ -0,0 +1,114 @@
+# I fondamentali del Prompt
+
+## Prompt di base
+
+Si può ottenere molto con semplici prompt, ma la qualità dei risultati dipende da quante informazioni vengono fornite e da quanto sono ben fatte. Un prompt può contenere informazioni come l'*istruzione* o la *domanda* che si sta passando al modello e includere altri dettagli come *contesto*, *ingressi* o *esempi*. Si possono usare questi elementi per istruire meglio il modello e di conseguenza ottenere risultati migliori.
+
+Cominciamo con un esempio di base di un semplice prompt:
+
+*Prompt*
+```
+Il cielo è
+```
+
+*Output:*
+```
+blu
+
+Il cielo è blu nelle giornate serene. In una giornata nuvolosa, il cielo può essere grigio o bianco.
+```
+
+Come si può vedere, il modello linguistico produce una serie di stringhe che hanno senso in base al contesto "Il cielo è". L'output potrebbe essere inaspettato o lontano dal compito che vogliamo svolgere. 
+
+Questo esempio di base evidenzia anche la necessità di fornire un contesto più ampio o istruzioni su ciò che si vuole ottenere nello specifico.
+
+Cerchiamo di migliorarlo un po':
+
+*Prompt:*
+```
+Completare la frase: 
+
+Il cielo è
+```
+
+*Output:*
+
+```
+così bello oggi.
+```
+
+È meglio? Beh, abbiamo detto al modello di completare la frase, quindi il risultato è molto migliore perché segue esattamente ciò che gli abbiamo detto di fare ("completare la frase"). Questo approccio, che consiste nel progettare prompt ottimali per istruire il modello a eseguire un compito, è definito **prompt engineering** (ingegneria dei prompt).
+
+L'esempio precedente è un'illustrazione di base di ciò che è possibile fare oggi con gli LLM. Gli LLM di oggi sono in grado di eseguire tutti i tipi di compiti avanzati, dalla sintesi del testo al ragionamento matematico alla generazione di codice.	
+
+## Formattazione del Prompt
+
+Abbiamo provato un prompt molto semplice. Un prompt standard ha il seguente formato:
+
+```
+<Domanda>?
+```
+
+oppure
+
+```
+<Istruzione>
+```
+ 
+Questo può essere formattato in un formato di risposta alle domande (QA), che è standard in molti set di dati QA, come segue:
+
+```
+D: <Domanda>?
+R: 
+```
+
+Quando si esegue un prompt come quello descritto sopra, si parla anche di *zero-shot* prompt (a colpo zero), cioè si sollecita direttamente il modello a dare una risposta senza alcun esempio o dimostrazione del compito che si vuole fargli svolgere. Alcuni modelli linguistici di grandi dimensioni sono in grado di eseguire zero-shot prompt, ma dipende dalla complessità e dalla conoscenza del compito da svolgere.
+
+Dato il formato standard di cui sopra, una tecnica popolare ed efficace di stimolo è quella denominata *few-shot* (a pochi colpi) prompt, in cui vengono forniti degli esempi (es. dimostrazioni). Le richieste few-shot possono essere formattate come segue:
+
+```
+<Domanda>?
+<Risposta>
+
+<Domanda>?
+<Risposta>
+
+<Domanda>?
+<Risposta>
+
+<Domanda>?
+
+```
+
+La versione del formato QA avrebbe il seguente aspetto:
+
+```
+Q: <Domanda>?
+A: <Risposta>
+
+Q: <Domanda>?
+A: <Risposta>
+
+Q: <Domanda>?
+A: <Risposta>
+
+Q: <Domanda>?
+A:
+```
+
+Tenete presente che non è obbligatorio utilizzare il formato QA. Il formato del prompt dipende dal compito da svolgere. Per esempio, si può eseguire un semplice compito di classificazione e fornire esempi che dimostrino il compito come segue:
+
+*Prompt:*
+```
+È fantastico! // Positivo
+Questo è brutto! // Negativo
+Wow, quel film era fantastico! // Positivo
+Che spettacolo orribile! //
+```
+
+*Output:*
+```
+Negativo
+```
+
+I prompt few-shot consentono l'apprendimento in contesto, ovvero la capacità dei modelli linguistici di apprendere compiti con poche dimostrazioni.

pages/introduction/elements.it.mdx

@@ -0,0 +1,15 @@
+# Elementi di un Prompt
+
+Man mano che si approfondiscono gli esempi e le applicazioni possibili con il prompt engineering, si noterà che ci sono alcuni elementi che compongono un prompt. 
+
+Un prompt può contenere uno dei seguenti componenti:
+
+**Istruzione** - un compito o un'istruzione specifica che il modello deve eseguire
+
+**Contesto** - può coinvolgere informazioni esterne o contesti aggiuntivi che possono indirizzare il modello verso risposte migliori.
+
+**Dati in Input** - è l'input o la domanda per la quale ci interessa trovare una risposta
+
+**Indicatore dell'Output** - indica il tipo o il formato dell'output.
+
+Non tutti i componenti sono necessari per un prompt e il formato dipende dal compito da svolgere. Nella guida verranno illustrati esempi più concreti.

pages/introduction/examples.it.mdx

@@ -0,0 +1,287 @@
+# Esempi di Prompt
+
+Nella sezione precedente, abbiamo introdotto e fornito esempi di base su come richiedere gli LLM.
+
+In questa sezione forniremo altri esempi di come i prompt vengono utilizzati per realizzare diversi compiti e introdurremo i concetti chiave lungo il percorso. Spesso, il modo migliore per imparare i concetti è attraverso gli esempi. Qui di seguito vengono illustrati alcuni esempi di come i prompt ben realizzati possano essere utilizzati per svolgere diversi tipi di compiti.
+
+Argomenti:
+- [Sintesi del testo](#text-summarization)
+- [Estrazione di informazioni](#information-extraction)
+- [Rispondere alle domande](#question-answering)
+- [Classificazione del testo](#text-classification)
+- [Conversazione](#conversation)
+- [Generazione di codice](#code-generation)
+- [Ragionamento](#reasoning)
+
+---
+
+## Sintesi del testo
+Uno dei compiti standard nella generazione del linguaggio naturale è la sintesi del testo. Il riassunto del testo può includere molti aspetti e domini diversi. In effetti, una delle applicazioni più promettenti dei modelli linguistici è la capacità di riassumere articoli e concetti in sintesi rapide e di facile lettura. Proviamo a svolgere un compito di riassunto di base utilizzando i prompt.
+
+Supponiamo che io sia interessato a conoscere gli antibiotici, potrei provare un prompt come questo:
+
+*Prompt:*
+```
+Spiega gli antibiotici
+
+R:
+```
+
+*Output:*
+```
+Gli antibiotici sono un tipo di farmaco utilizzato per trattare le infezioni batteriche. Agiscono uccidendo i batteri o impedendo loro di riprodursi, consentendo al sistema immunitario dell'organismo di combattere l'infezione. Gli antibiotici vengono solitamente assunti per via orale sotto forma di pillole, capsule o soluzioni liquide, o talvolta somministrati per via endovenosa. Non sono efficaci contro le infezioni virali e il loro uso inappropriato può portare alla resistenza agli antibiotici.
+```
+
+"R:" è un formato di prompt esplicito che viene utilizzato nelle risposte alle domande. Qui l'ho usato per dire al modello che c'è un'ulteriore attesa. In questo esempio, non è chiaro in che modo sia utile rispetto a non usarlo, ma lo lasceremo per gli esempi successivi. Supponiamo che queste informazioni siano troppe e che si voglia riassumerle ulteriormente. In effetti, possiamo istruire il modello a riassumere in una frase come questa:
+
+*Prompt:*
+```
+Gli antibiotici sono un tipo di farmaco utilizzato per trattare le infezioni batteriche. Agiscono uccidendo i batteri o impedendo loro di riprodursi, consentendo al sistema immunitario dell'organismo di combattere l'infezione. Gli antibiotici vengono solitamente assunti per via orale sotto forma di pillole, capsule o soluzioni liquide, o talvolta somministrati per via endovenosa. Non sono efficaci contro le infezioni virali e il loro uso inappropriato può portare alla resistenza agli antibiotici.
+
+Spiega quanto sopra in una frase:
+```
+
+*Output:*
+```
+Gli antibiotici sono farmaci utilizzati per trattare le infezioni batteriche uccidendo i batteri o impedendo loro di riprodursi, ma non sono efficaci contro i virus e un uso eccessivo può portare alla resistenza agli antibiotici.
+```
+
+Senza prestare troppa attenzione all'accuratezza dell'output di cui sopra, che è un aspetto che tratteremo in una guida successiva, il modello ha cercato di riassumere il paragrafo in una frase. È possibile agire in modo intelligente con le istruzioni, ma questo aspetto sarà trattato in un capitolo successivo. Sentitevi liberi di fermarvi qui e di sperimentare per vedere se ottenete risultati migliori.
+
+---
+## Estrazione di informazioni
+Sebbene i modelli linguistici siano addestrati per eseguire la generazione del linguaggio naturale e i compiti correlati, sono anche in grado di eseguire la classificazione e una serie di altri compiti di elaborazione del linguaggio naturale (NLP). 
+
+Ecco un esempio di prompt che estrae informazioni da un determinato paragrafo.
+
+*Prompt:*
+```
+Le dichiarazioni di contributo degli autori e i ringraziamenti nei documenti di ricerca devono indicare chiaramente e specificamente se, e in che misura, gli autori hanno utilizzato tecnologie di IA come ChatGPT nella preparazione del manoscritto e dell'analisi. Dovrebbero anche indicare quali LLM sono state utilizzate. In questo modo i redattori e i revisori saranno in grado di esaminare più attentamente i manoscritti per individuare potenziali pregiudizi, imprecisioni e accreditamenti impropri delle fonti. Allo stesso modo, le riviste scientifiche dovrebbero essere trasparenti sull'uso dei LLM, ad esempio nella selezione dei manoscritti presentati.
+
+Cita il prodotto basato su un modello linguistico di grandi dimensioni menzionato nel paragrafo precedente:
+```
+
+*Output:*
+```
+Il prodotto menzionato nel paragrafo precedente è basato sul modello linguistico di grandi dimensioni ChatGPT.
+```
+
+Ci sono molti modi per migliorare i risultati di cui sopra, ma questo è già molto utile.
+
+A questo punto dovrebbe essere ovvio che si può chiedere al modello di eseguire compiti diversi semplicemente dandogli istruzioni su cosa fare. Si tratta di una capacità potente che gli sviluppatori di prodotti di intelligenza artificiale stanno già utilizzando per creare prodotti ed esperienze di grande impatto.
+
+Fonte del paragrafo: [ChatGPT: cinque priorità per la ricerca](https://www.nature.com/articles/d41586-023-00288-7) 
+
+---
+## Rispondere alle domande
+
+Uno dei modi migliori per far sì che il modello risponda a risposte specifiche è migliorare il formato del prompt. Come già detto, un prompt può combinare istruzioni, contesto, indicatori di input e output per ottenere risultati migliori. Anche se questi componenti non sono obbligatori, si tratta di una buona pratica, poiché quanto più specifiche sono le istruzioni, tanto migliori saranno i risultati. Di seguito è riportato un esempio di come potrebbe apparire un prompt più strutturato.
+
+*Prompt:*
+```
+Rispondi alla domanda basandoti sul contesto sottostante. Rispondi in modo breve e conciso. Rispondi "Incertezza sulla risposta" se non si è sicuri della risposta.
+
+Contesto: Il teplizumab affonda le sue radici in un'azienda farmaceutica del New Jersey, la Ortho Pharmaceutical. Qui gli scienziati hanno generato una prima versione dell'anticorpo, denominata OKT3. Originariamente ottenuta dai topi, la molecola era in grado di legarsi alla superficie delle cellule T e di limitarne il potenziale di uccisione. Nel 1986 è stato approvato per aiutare a prevenire il rigetto degli organi dopo il trapianto di rene, diventando così il primo anticorpo terapeutico autorizzato per uso umano.
+
+Domanda: Da cosa è stato originariamente ricavato l'OKT3?
+
+Risposta:
+```
+
+*Output:*
+```
+Topi.
+```
+
+Contesto ottenuto da [Nature](https://www.nature.com/articles/d41586-023-00400-x).
+
+---
+
+## Classificazione del testo
+Finora abbiamo usato istruzioni semplici per eseguire un compito. Come ingegnere del prompt, dovrete migliorare nel fornire istruzioni più precise. Ma non è tutto! Scoprirete anche che per i casi d'uso più difficili, fornire solo istruzioni non sarà sufficiente. È qui che bisogna pensare di più al contesto e ai diversi elementi che si possono usare in un prompt. Altri elementi che si possono fornire sono i `dati di ingresso' o gli `esempi'. 
+
+Proviamo a dimostrarlo fornendo un esempio di classificazione del testo.
+
+*Prompt:*
+```
+Classificare il testo in neutro, negativo o positivo. 
+
+Testo: Penso che il cibo fosse buono. 
+Sentimento:
+```
+
+*Output:*
+```
+Neutro
+```
+
+Abbiamo dato l'istruzione di classificare il testo e il modello ha risposto con `'Neutro'', che è corretto. Non c'è nulla di male in questo, ma diciamo che ciò di cui abbiamo bisogno è che il modello fornisca l'etichetta nel formato esatto che vogliamo. Quindi, invece di `Neutro` vogliamo che restituisca `neutrale`. Come possiamo ottenere questo risultato? Ci sono diversi modi per farlo. Ci interessa la specificità, quindi più informazioni possiamo fornire al prompt e migliori saranno i risultati. Possiamo provare a fornire degli esempi per specificare il comportamento corretto. Proviamo di nuovo:
+
+*Prompt:*
+```
+Classificare il testo in neutrale, negativo o positivo. 
+
+Testo: Penso che la vacanza vada bene.
+Sentimento: neutrale
+
+Testo: Penso che il cibo fosse buono. 
+Sentimento:
+```
+
+*Output:*
+```
+neutrale
+```
+
+Perfetto! Questa volta il modello ha restituito `neutrale` che è l'etichetta specifica che stavo cercando. Sembra che l'esempio fornito nel prompt abbia aiutato il modello a essere specifico nel suo output. Per evidenziare perché a volte essere specifici è importante, date un'occhiata a questo esempio e individuate il problema:
+
+*Prompt:*
+```
+Classificare il testo in nutritivo, negativo o positivo. 
+
+Testo: Penso che le vacanze vadano bene.
+Sentimento:
+```
+
+*Output:*
+```
+Neutro
+```
+
+Dove è il problema?
+
+---
+
+## Conversazione
+Forse una delle cose più interessanti che si possono ottenere con il prompt engineering è istruire il sistema LLM su come comportarsi, sulle sue intenzioni e sulla sua identità. Questo è particolarmente utile quando si costruiscono sistemi conversazionali come i chatbot del servizio clienti.
+
+Per esempio, creiamo un sistema conversazionale in grado di generare risposte più tecniche e scientifiche alle domande. Notate come gli stiamo dicendo esplicitamente come comportarsi attraverso le istruzioni. Questo viene a volte definito "prompting di ruolo".
+
+*Prompt:*
+```
+La seguente è una conversazione con un assistente di ricerca di intelligenza artificiale (AI). Il tono dell'assistente è tecnico e scientifico.
+
+Persona: Ciao, chi sei?
+IA: Saluto! Sono un assistente di ricerca AI. Come posso aiutarla oggi?
+Persona: Puoi parlarmi della creazione dei buchi neri?
+IA:
+```
+
+*Output:*
+```
+Certo! I buchi neri sono regioni dello spaziotempo in cui la forza gravitazionale è così forte che nulla, nemmeno la luce, può uscirne. Si creano quando una stella molto massiccia muore e il suo nucleo collassa su se stesso, formando una singolarità di densità infinita. L'intensa gravità della singolarità attira tutta la materia e le radiazioni che la circondano, creando il buco nero.
+```
+
+Il nostro assistente di ricerca AI sembra un po' troppo tecnico, vero? Ok, cambiamo questo comportamento e istruiamo il sistema a dare risposte più accessibili. 
+
+*Prompt:*
+```
+La seguente è una conversazione con un assistente di ricerca AI. Le risposte dell'assistente dovrebbero essere facili da capire anche per gli studenti delle scuole elementari.
+
+Persona: Ciao, chi sei?
+IA: Ciao! Sono un assistente di ricerca AI. Come posso aiutarti oggi?
+Persona: Puoi parlarmi della creazione dei buchi neri?
+IA: 
+```
+
+*Output:*
+```
+Certo! I buchi neri si formano quando una stella molto massiccia esaurisce il suo carburante e collassa su se stessa. La gravità della stella è così forte che nulla, nemmeno la luce, può sfuggire alla sua attrazione. Si crea così un punto nello spazio-tempo con un'intensa forza gravitazionale, chiamato buco nero.
+```
+
+Penso che abbiamo fatto dei progressi. Potete continuare a migliorarlo. Sono sicuro che se aggiungerete altri esempi potrete ottenere risultati ancora migliori. 
+
+---
+
+## Generazione di codice
+Un'applicazione in cui gli LLM sono molto efficaci è la generazione di codice. Copilot ne è un ottimo esempio. È possibile eseguire un gran numero di operazioni di generazione di codice con suggerimenti intelligenti. Vediamo di seguito alcuni esempi.
+
+Per prima cosa, proviamo un semplice programma che saluta l'utente.
+
+*Prompt:*
+```
+/*
+Chiedete all'utente il suo nome e di "Ciao".
+*/
+```
+
+*Output:*
+```
+let name = prompt("Quale è il tuo nome?");
+console.log(`Ciao, ${name}!`);
+```
+
+Si può notare che non è stato necessario specificare la lingua da utilizzare.
+
+Cambiamo un po' livello. Voglio mostrarvi quanto possano essere potenti gli LLM con un po' più di impegno nella progettazione dei prompt.
+
+*Prompt:*
+```
+"""
+Tabella reparti, colonne = [DepartmentId, DepartmentName]
+Tabella studenti, colonne = [DepartmentId, StudentId, StudentName]
+Creare una query MySQL per tutti gli studenti del dipartimento di Informatica.
+"""
+```
+
+*Output:*
+```
+SELECT StudentId, StudentName 
+FROM students 
+WHERE DepartmentId IN (SELECT DepartmentId FROM departments WHERE DepartmentName = 'Informatica');
+```
+
+È davvero impressionante. In questo caso, abbiamo fornito dati sullo schema del database e gli abbiamo chiesto di generare una query MySQL valida. 
+
+---
+
+## Ragionamento
+Forse uno dei compiti più difficili per un LLM oggi è quello che richiede una qualche forma di ragionamento. Il ragionamento è una delle aree che mi entusiasmano di più, per il tipo di applicazioni complesse che possono emergere dai LLM.
+
+Ci sono stati alcuni miglioramenti nei compiti che richiedono capacità matematiche. Detto questo, è importante notare che gli attuali LLM faticano a svolgere compiti di ragionamento, quindi questo richiede tecniche di prompt engineering ancora più avanzate. Queste tecniche avanzate saranno trattate più avanti. Per il momento, ci occuperemo di alcuni esempi di base per mostrare le capacità aritmetiche.
+
+*Prompt:*
+```
+Cosa fa 9.000 * 9.000?
+```
+
+*Output:*
+```
+81.000.000
+```
+
+Proviamo a fare qualcosa di più difficile. 
+
+*Prompt:*
+```
+La somma dei numeri dispari di questo gruppo genera un numero pari: 15, 32, 5, 13, 82, 7, 1. 
+
+R: 
+```
+
+*Output*
+```
+No, i numeri dispari di questo gruppo sommati generano un numero dispari: 119.
+```
+
+Non è corretto! Cerchiamo di migliorare questo aspetto migliorando il prompt.
+
+*Prompt:*
+```
+La somma dei numeri dispari di questo gruppo genera un numero pari: 15, 32, 5, 13, 82, 7, 1. 
+
+Risolvi il problema suddividendolo in fasi. Prima, individua i numeri dispari, poi sommali ed indica se il risultato è pari o dispari. 
+```
+
+*Output:*
+```
+Numeri dispari: 15, 5, 13, 7, 1
+Somma: 41 
+41 è un numero dispari.
+```
+
+Molto meglio, no? A proposito, ho provato a farlo un paio di volte e il sistema a volte fallisce. Se si fornissero istruzioni migliori e esempi, si potrebbero ottenere risultati più precisi.
+
+Continueremo a includere altri esempi di applicazioni comuni in questa sezione della guida.
+
+Nella prossima sezione tratteremo concetti e tecniche di prompt engineering ancora più avanzati per migliorare le prestazioni di questi e di altri compiti più difficili.

pages/introduction/settings.it.mdx

@@ -0,0 +1,11 @@
+# Impostazioni LLM
+
+Quando si lavora con i prompt, si interagisce con l'LLM tramite un'API o direttamente. È possibile configurare alcuni parametri per ottenere risultati diversi per i prompt. 
+
+**Temperature** - In breve, più bassa è la `temperatura`, più deterministici sono i risultati, nel senso che viene sempre scelto il token successivo più probabile. Un aumento della temperatura potrebbe portare a una maggiore casualità, incoraggiando risultati più diversi o creativi. In sostanza, stiamo aumentando il peso degli altri possibili token. In termini di applicazione, potremmo voler utilizzare un valore di temperatura più basso per compiti come l'AQ basata sui fatti, per incoraggiare risposte più concrete e concise. Per la generazione di poesie o altri compiti creativi, potrebbe essere utile aumentare il valore della temperatura.
+
+**Top_p** - Allo stesso modo, con `top_p`, una tecnica di campionamento con temperatura chiamata campionamento del nucleo, si può controllare quanto il modello sia deterministico nel generare una risposta. Se siete alla ricerca di risposte esatte e concrete, tenete questo valore basso. Se si cercano risposte più diversificate, aumentare il valore a un valore più alto. 
+
+La raccomandazione generale è di modificarne uno, non entrambi.
+
+Prima di iniziare con alcuni esempi di base, tenete presente che i risultati possono variare a seconda della versione di LLM che state utilizzando.

pages/introduction/tips.it.mdx

@@ -0,0 +1,108 @@
+# Suggermenti generali per la progettazione di Prompt
+
+Ecco alcuni suggerimenti da tenere a mente durante la progettazione dei tuoi prompt:
+
+
+### Inizio semplice
+Quando si inizia a progettare i prompt, bisogna tenere presente che si tratta di un processo iterativo che richiede molta sperimentazione per ottenere risultati ottimali. L'utilizzo di una semplice strumento come OpenAI o Cohere è un buon punto di partenza.
+
+Si può iniziare con prompt semplici e aggiungere altri elementi e contesti man mano che si punta a ottenere risultati migliori. Per questo motivo è fondamentale modificare i suggerimenti durante il percorso. Leggendo la guida, vedrete molti esempi in cui la specificità, la semplicità e la concisione vi daranno spesso risultati migliori.
+
+Quando si ha un compito importante che coinvolge molte sottoattività diverse, si può cercare di suddividere il compito in sottoattività più semplici e continuare ad aumentare man mano che si ottengono risultati migliori. In questo modo si evita di aggiungere troppa complessità al processo di progettazione del prompt all'inizio.
+
+### Le istruzioni
+È possibile progettare prompt efficaci per vari compiti semplici, utilizzando comandi per indicare al modello ciò che si desidera ottenere, come "Scrivi", "Classifica", "Riassumi", "Traduci", "Ordina", ecc.
+
+Tenete presente che dovete anche sperimentare molto per capire cosa funziona meglio. Provate diverse istruzioni con parole chiave, contesti e dati diversi e vedete cosa funziona meglio per il vostro caso d'uso e la vostra attività. Di solito, più il contesto è specifico e rilevante per l'attività che si sta cercando di svolgere, meglio è. Nelle prossime guide parleremo dell'importanza del campionamento e dell'aggiunta di ulteriore contesto.
+
+Altri raccomandano di collocare le istruzioni all'inizio del prompt. Si raccomanda anche di usare un separatore chiaro, come "###", per separare l'istruzione dal contesto.
+
+Per esempio:
+
+*Prompt:*
+```
+### Istruzione ###
+Traduci il seguente testo in spagnolo
+
+Testo: "ciao!"
+```
+
+*Output:*
+```
+¡Hola!
+```
+
+### Specificity
+Be very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results. This is particularly important when you have a desired outcome or style of generation you are seeking. There aren't specific tokens or keywords that lead to better results. It's more important to have a good format and descriptive prompt. In fact, providing examples in the prompt is very effective to get desired output in specific formats.
+
+When designing prompts you should also keep in mind the length of the prompt as there are limitations regarding how long this can be. Thinking about how specific and detailed you should be is something to consider. Including too many unnecessary details is not necessarily a good approach. The details should be relevant and contribute to the task at hand. This is something you will need to experiment with a lot. We encourage a lot of experimentation and iteration to optimize prompts for your applications.
+
+As an example, let's try a simple prompt to extract specific information from a piece of text.
+
+*Prompt:*
+```
+Extract the name of places in the following text. 
+
+Desired format:
+Place: <comma_separated_list_of_company_names>
+
+Input: "Although these developments are encouraging to researchers, much is still a mystery. “We often have a black box between the brain and the effect we see in the periphery,” says Henrique Veiga-Fernandes, a neuroimmunologist at the Champalimaud Centre for the Unknown in Lisbon. “If we want to use it in the therapeutic context, we actually need to understand the mechanism.""
+```
+
+*Output:*
+```
+Place: Champalimaud Centre for the Unknown, Lisbon
+```
+
+Input text is obtained from [this Nature article](https://www.nature.com/articles/d41586-023-00509-z).
+
+### Avoid Impreciseness
+
+Given the tips above about being detailed and improving format, it's easy to fall into the trap of wanting to be too clever about prompts and potentially creating imprecise descriptions. It's often better to be specific and direct. The analogy here is very similar to effective communication -- the more direct, the more effective the message gets across.
+
+For example, you might be interested in learning the concept of prompt engineering. You might try something like:
+
+```
+Explain the concept prompt engineering. Keep the explanation short, only a few sentences, and don't be too descriptive.
+```
+
+It's not clear from the prompt above how many sentences to use and what style. You might still somewhat get good responses with the above prompts but the better prompt would be one that is very specific, concise, and to the point. Something like:
+
+```
+Use 2-3 sentences to explain the concept of prompt engineering to a high school student.
+```
+
+### To do or not to do?
+Another common tip when designing prompts is to avoid saying what not to do but say what to do instead. This encourages more specificity and focuses on the details that lead to good responses from the model.
+
+Here is an example of a movie recommendation chatbot failing at exactly what I don't want it to do because of how I wrote the instruction -- focusing on what not to do.
+
+*Prompt:*
+```
+The following is an agent that recommends movies to a customer. DO NOT ASK FOR INTERESTS. DO NOT ASK FOR PERSONAL INFORMATION.
+
+Customer: Please recommend a movie based on my interests.
+Agent: 
+```
+
+*Output:*
+```
+Sure, I can recommend a movie based on your interests. What kind of movie would you like to watch? Do you prefer action, comedy, romance, or something else?
+```
+
+Here is a better prompt:
+
+*Prompt:*
+```
+The following is an agent that recommends movies to a customer. The agent is responsible to recommend a movie from the top global trending movies. It should refrain from asking users for their preferences and avoid asking for personal information. If the agent doesn't have a movie to recommend, it should respond "Sorry, couldn't find a movie to recommend today.".
+
+Customer: Please recommend a movie based on my interests.
+Agent:
+```
+
+*Output:*
+```
+Sorry, I don't have any information about your interests. However, here's a list of the top global trending movies right now: [list of movies]. I hope you find something you like!
+```
+
+Some of the examples above were adopted from the ["Best practices for prompt engineering with OpenAI API" article.](https://help.openai.com/en/articles/6654000-best-practices-for-prompt-engineering-with-openai-api)