Merge branch 'main' into i18n_es

.gitignore

@@ -9,7 +9,9 @@ notebooks/__pycache__/
 notebooks/state_of_the_union.txt
 notebooks/chroma_logs.log
 notebooks/.chroma/
+notebooks/.env
 .DS_Store
+.vscode
 
 # app
 .next

README.md

@@ -9,7 +9,7 @@ Happy Prompting!
 ---
 ## Announcements / Updates
 
-- 🌐 We now support [中文](https://www.promptingguide.ai/zh), [日本語](https://www.promptingguide.ai/jp), [Português](https://www.promptingguide.ai/pt) and [English](https://www.promptingguide.ai/). Welcoming more translations.
+- 🌐 We now support [中文](https://www.promptingguide.ai/zh), [日本語](https://www.promptingguide.ai/jp), [Português](https://www.promptingguide.ai/pt), [Turkish](https://www.promptingguide.ai/tr) and [English](https://www.promptingguide.ai/). Welcoming more translations.
 - 🎉 We have launched new web version of the guide [here](https://www.promptingguide.ai/)
 - 🎓 Partnered with Sphere to deliver a new course on [Prompt Engineering for LLMs](https://www.getsphere.com/cohorts/prompt-engineering-for-llms?source=github)
 - 🔥 We reached #1 on Hacker News on 21 Feb 2023
@@ -47,6 +47,15 @@ Please note that the guides below are now outdated. You can find the most up-to-
 - [Prompt Engineering - Datasets](/pages/datasets.en.mdx) 
 - [Prompt Engineering - Additional Readings](/pages/readings.en.mdx)
 
+---
+
+## Appearances
+Some places where we have been featured:
+- Wall Street Journal - [ChatGPT Can Give Great Answers. But Only If You Know How to Ask the Right Question](https://www.wsj.com/articles/chatgpt-ask-the-right-question-12d0f035)
+- Forbes - [Mom, Dad, I Want To Be A Prompt Engineer](https://www.forbes.com/sites/craigsmith/2023/04/05/mom-dad-i-want-to-be-a-prompt-engineer/?sh=7f1213159c8e)
+- Markettechpost - [Best Free Prompt Engineering Resources (2023)](https://www.marktechpost.com/2023/04/04/best-free-prompt-engineering-resources-2023/)
+
+
 ---
 If you are using the guide for your work, please cite us as follows:
 

notebooks/react.ipynb

@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ReAct Prompting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "# update or install the necessary libraries\n",
+    "!pip install --upgrade openai\n",
+    "!pip install --upgrade langchain\n",
+    "!pip install --upgrade python-dotenv\n",
+    "!pip install google-search-results\n",
+    "\n",
+    "# import libraries\n",
+    "import openai\n",
+    "import os\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.agents import load_tools\n",
+    "from langchain.agents import initialize_agent\n",
+    "from dotenv import load_dotenv\n",
+    "load_dotenv()\n",
+    "\n",
+    "# load API keys; you will need to obtain these if you haven't yet\n",
+    "os.environ[\"OPENAI_API_KEY\"] = os.getenv(\"OPENAI_API_KEY\")\n",
+    "os.environ[\"SERPAPI_API_KEY\"] = os.getenv(\"SERPAPI_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(model_name=\"text-davinci-003\" ,temperature=0)\n",
+    "tools = load_tools([\"serpapi\", \"llm-math\"], llm=llm)\n",
+    "agent = initialize_agent(tools, llm, agent=\"zero-shot-react-description\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power.\n",
+      "Action: Search\n",
+      "Action Input: \"Olivia Wilde boyfriend\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mOlivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find out Harry Styles' age.\n",
+      "Action: Search\n",
+      "Action Input: \"Harry Styles age\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m29 years\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to calculate 29 raised to the 0.23 power.\n",
+      "Action: Calculator\n",
+      "Action Input: 29^0.23\u001b[0m\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 2.169459462491557\n",
+      "\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.\""
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# run the agent\n",
+    "agent.run(\"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "langchain",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pages/_app.tsx

@@ -1,6 +1,7 @@
 import type { AppProps } from 'next/app';
 import Script from 'next/script';
 import { Analytics } from '@vercel/analytics/react';
+import './style.css';
  
 function MyApp({ Component, pageProps }: AppProps) {
   return (

pages/index.pt.mdx

@@ -1,9 +1,9 @@
 # Guia de Engenharia Prompt
 
-A engenharia de prompts é uma disciplina relativamente nova para desenvolver e otimizar prompts para usar eficientemente modelos de linguagem (LMs) para uma ampla variedade de aplicativos e tópicos de pesquisa. As habilidades de engenharia de prompt ajudam a entender melhor os recursos e as limitações dos modelos de linguagem grandes (LLMs).
+A engenharia de prompts é uma disciplina relativamente nova que visa desenvolver e otimizar prompts e utilizar eficientemente modelos de linguagem (LMs) para uma ampla variedade de aplicativos e tópicos de pesquisa. As habilidades de engenharia de prompt ajudam a entender melhor os recursos e as limitações dos modelos de linguagem grandes (LLMs).
 
 Os pesquisadores usam a engenharia de prompt para melhorar a capacidade dos LLMs em uma ampla gama de tarefas comuns e complexas, como resposta a perguntas e raciocínio aritmético. Os desenvolvedores usam engenharia de prompt para projetar técnicas de prompt robustas e eficazes que fazem interface com LLMs e outras ferramentas.
 
-A engenharia de prompts não é apenas projetar e desenvolver prompts. Abrange uma ampla gama de habilidades e técnicas que são úteis para interagir e desenvolver com LLMs. É uma habilidade importante interagir, construir e entender os recursos dos LLMs. Você pode usar a engenharia de prompt para melhorar a segurança dos LLMs e criar novos recursos, como aumentar os LLMs com conhecimento de domínio e ferramentas externas.
+A engenharia de prompts não é apenas projetar e desenvolver prompts. Abrange uma ampla gama de habilidades e técnicas que são úteis para interagir e desenvolver com LLMs. É uma habilidade importante para interagir, construir e entender os recursos dos LLMs. Você pode usar a engenharia de prompt para melhorar a segurança dos LLMs e criar novos recursos, como aumentar os LLMs com conhecimento de domínio e ferramentas externas.
 
-Motivados pelo grande interesse em desenvolver com LLMs, criamos este novo guia de engenharia rápida que contém todos os artigos mais recentes, guias de aprendizagem, modelos, palestras, referências, novos recursos de LLM e ferramentas relacionadas à engenharia rápida.
+Motivados pelo grande interesse em desenvolver com LLMs, criamos este novo guia de engenharia rápida que contém todos os artigos mais recentes, guias de aprendizagem, modelos, palestras, referências, novos recursos de LLM e ferramentas relacionadas à engenharia de prompt.

pages/introduction.pt.mdx

@@ -2,6 +2,6 @@
 
 A engenharia de prompts é uma disciplina relativamente nova para desenvolver e otimizar prompts para usar eficientemente modelos de linguagem (LMs) para uma ampla variedade de aplicativos e tópicos de pesquisa. As habilidades imediatas de engenharia ajudam a entender melhor os recursos e as limitações dos modelos de linguagem grandes (LLMs). Os pesquisadores usam a engenharia de prompt para melhorar a capacidade dos LLMs em uma ampla gama de tarefas comuns e complexas, como resposta a perguntas e raciocínio aritmético. Os desenvolvedores usam engenharia de prompt para projetar técnicas de prompt robustas e eficazes que fazem interface com LLMs e outras ferramentas.
 
-Este guia aborda os fundamentos dos prompts para fornecer uma ideia aproximada de como usar prompts para interagir e instruir modelos de linguagem grandes (LLMs).
+Este guia aborda os fundamentos dos prompts para fornecer uma ideia aproximada de como utiliza-los para interagir e instruir modelos de linguagem grandes (LLMs).
 
 Todos os exemplos são testados com `text-davinci-003` (usando o playground do OpenAI), a menos que especificado de outra forma. Ele usa as configurações padrão, ou seja, `temperatura=0.7` e `top-p=1`.

pages/introduction/basics.pt.mdx

@@ -58,13 +58,13 @@ ou
 Isso pode ser formatado em um formato de resposta a perguntas (QA), que é padrão em muitos conjuntos de dados de QA, como segue:
 
 ```
-P: <Pergunta>?
+Q: <Pergunta>?
 A:
 ```
 
-Ao solicitar como o acima, também é chamado de *prompt de tiro zero*, ou seja, você está solicitando diretamente ao modelo uma resposta sem nenhum exemplo ou demonstração sobre a tarefa que deseja realizar. Alguns modelos de linguagem grandes têm a capacidade de executar prompts zero-shot, mas isso depende da complexidade e do conhecimento da tarefa em questão.
+Ao solicitar como o acima, também chamado de *prompt de tiro zero*, ou seja, você está solicitando diretamente ao modelo uma resposta sem nenhum exemplo ou demonstração sobre a tarefa que deseja realizar. Alguns modelos de linguagem grandes têm a capacidade de executar prompts zero-shot, mas isso depende da complexidade e do conhecimento da tarefa em questão.
 
-Dado o formato padrão acima, uma técnica popular e eficaz para solicitação é chamada de *promoção de poucos tiros*, onde fornecemos exemplos (ou seja, demonstrações). Os prompts de poucas fotos podem ser formatados da seguinte maneira:
+Dado o formato padrão acima, uma técnica popular e eficaz para solicitação é chamada de *prompt de poucos tiros*, onde fornecemos exemplos (ou seja, demonstrações). Os prompts de poucos tiros podem ser formatados da seguinte maneira:
 
 ```
 <Pergunta>?
@@ -83,16 +83,16 @@ Dado o formato padrão acima, uma técnica popular e eficaz para solicitação
 A versão do formato QA ficaria assim:
 
 ```
-P: <Pergunta>?
+Q: <Pergunta>?
-R: <Resposta>
+A: <Resposta>
 
-P: <Pergunta>?
+Q: <Pergunta>?
-R: <Resposta>
+A: <Resposta>
 
-P: <Pergunta>?
+Q: <Pergunta>?
-R: <Resposta>
+A: <Resposta>
 
-P: <Pergunta>?
+Q: <Pergunta>?
 A:
 ```
 
@@ -102,7 +102,7 @@ Lembre-se de que não é necessário usar o formato QA. O formato do prompt depe
 ```
 Isso é incrível! // Positivo
 Isto é mau! // Negativo
-Uau, esse filme foi rad! // Positivo
+Uau, esse filme foi radical! // Positivo
 Que espetáculo horrível! //
 ```
 
@@ -111,4 +111,4 @@ Que espetáculo horrível! //
 Negativo
 ```
 
-Os prompts de poucos disparos permitem o aprendizado no contexto, que é a capacidade dos modelos de linguagem de aprender tarefas dadas algumas demonstrações.
+Os prompts de poucos tiros permitem o aprendizado no contexto, que é a capacidade dos modelos de linguagem de aprender tarefas dadas algumas demonstrações.

pages/introduction/examples.pt.mdx

@@ -16,7 +16,7 @@ Tópicos:
 ---
 
 ## Resumo de texto
-Uma das tarefas padrão na geração de linguagem natural é o resumo de texto. A sumarização de texto pode incluir muitos sabores e domínios diferentes. Na verdade, uma das aplicações mais promissoras dos modelos de linguagem é a capacidade de resumir artigos e conceitos em resumos rápidos e fáceis de ler. Vamos tentar uma tarefa básica de resumo usando prompts.
+Uma das tarefas padrão na geração de linguagem natural é o resumo de texto. A sumarização de texto pode incluir preferências e domínios diferentes. Na verdade, uma das aplicações mais promissoras dos modelos de linguagem é a capacidade de resumir artigos e conceitos em resumos rápidos e fáceis de ler. Vamos tentar uma tarefa básica de resumo usando prompts.
 
 Digamos que estou interessado em aprender sobre antibióticos, poderia tentar um prompt como este:
 
@@ -38,7 +38,7 @@ O "A:" é um formato de prompt explícito usado para responder perguntas. Eu use
 ```
 Os antibióticos são um tipo de medicamento usado para tratar infecções bacterianas. Eles funcionam matando as bactérias ou impedindo-as de se reproduzir, permitindo que o sistema imunológico do corpo combata a infecção. Os antibióticos são geralmente tomados por via oral na forma de comprimidos, cápsulas ou soluções líquidas, ou às vezes administrados por via intravenosa. Eles não são eficazes contra infecções virais e usá-los de forma inadequada pode levar à resistência aos antibióticos.
 
-Explique o que foi dito acima em uma frase:
+**Explique o que foi dito acima em uma frase**:
 ```
 
 *Saída:*
@@ -58,7 +58,7 @@ Aqui está um exemplo de um prompt que extrai informações de um determinado pa
 ```
 As declarações de contribuição do autor e os agradecimentos em trabalhos de pesquisa devem indicar clara e especificamente se, e em que medida, os autores usaram tecnologias de IA, como ChatGPT, na preparação de seus manuscritos e análises. Eles também devem indicar quais LLMs foram usados. Isso alertará os editores e revisores para examinar os manuscritos com mais cuidado em busca de possíveis vieses, imprecisões e créditos de origem impróprios. Da mesma forma, os periódicos científicos devem ser transparentes sobre o uso de LLMs, por exemplo, ao selecionar manuscritos enviados.
 
-Mencione o produto baseado em modelo de linguagem grande mencionado no parágrafo acima:
+**Mencione o produto baseado em modelo de linguagem grande mencionado no parágrafo acima**:
 ```
 
 *Saída:*
@@ -197,7 +197,7 @@ Acho que fizemos algum progresso. Você pode continuar melhorando. Tenho certeza
 ---
 
 ## Geração de Código
-Uma aplicação em que os LLMs são bastante eficazes é a geração de código. O copiloto é um ótimo exemplo disso. Há um grande número de tarefas de geração de código que você pode executar com prompts inteligentes. Vejamos alguns exemplos abaixo.
+Uma aplicação em que os LLMs são bastante eficazes é a geração de código. O Copilot é um ótimo exemplo disso. Há um grande número de tarefas de geração de código que você pode executar com prompts inteligentes. Vejamos alguns exemplos abaixo.
 
 Primeiro, vamos tentar um programa simples que saúda o usuário.
 
@@ -241,7 +241,7 @@ Isso é muito impressionante. Nesse caso, fornecemos dados sobre o esquema do ba
 ## Raciocínio
 Talvez uma das tarefas mais difíceis para um LLM hoje seja aquela que requer alguma forma de raciocínio. O raciocínio é uma das áreas que mais me entusiasma devido aos tipos de aplicativos complexos que podem surgir dos LLMs.
 
-Houve algumas melhorias em tarefas envolvendo capacidades matemáticas. Dito isso, é importante observar que os LLMs atuais lutam para executar tarefas de raciocínio, portanto, isso requer técnicas de engenharia imediata ainda mais avançadas. Abordaremos essas técnicas avançadas no próximo guia. Por enquanto, abordaremos alguns exemplos básicos para mostrar as capacidades aritméticas.
+Houve algumas melhorias em tarefas envolvendo capacidades matemáticas. Dito isso, é importante observar que os LLMs atuais lutam para executar tarefas de raciocínio, portanto, isso requer técnicas de engenharia de prompt ainda mais avançadas. Abordaremos essas técnicas avançadas no próximo guia. Por enquanto, abordaremos alguns exemplos básicos para mostrar as capacidades aritméticas.
 
 *Prompt:*
 ```

pages/introduction/settings.pt.mdx

@@ -1,10 +1,10 @@
 # Configurações LLM
 
-Ao trabalhar com prompts, você estará interagindo com o LLM por meio de uma API ou diretamente. Você pode configurar alguns parâmetros para obter resultados diferentes para seus prompts.
+Ao trabalhar com prompts, você estará interagindo com o LLM diretamente ou por meio de uma API. Você pode configurar alguns parâmetros para obter resultados diferentes para seus prompts.
 
-**Temperatura** - Resumindo, quanto menor a `temperatura`, mais determinísticos são os resultados, no sentido de que o próximo token provável mais alto é sempre escolhido. O aumento da temperatura pode levar a mais aleatoriedade, incentivando saídas mais diversificadas ou criativas. Estamos essencialmente aumentando os pesos dos outros tokens possíveis. Em termos de aplicação, podemos querer usar um valor de temperatura mais baixo para tarefas como controle de qualidade baseado em fatos para encorajar respostas mais factuais e concisas. Para geração de poemas ou outras tarefas criativas, pode ser benéfico aumentar o valor da temperatura.
+**Temperatura** - Resumindo, quanto menor a `temperatura`, mais determinísticos são os resultados, no sentido de que o próximo token provável mais alto é sempre escolhido. O aumento da temperatura pode levar a mais aleatoriedade, incentivando saídas mais diversificadas ou criativas. Estamos essencialmente aumentando os pesos dos outros tokens possíveis. Em termos de aplicação, podemos querer usar um valor de temperatura mais baixo para tarefas como controle de qualidade baseado em fatos encorajando respostas mais factuais e concisas. Para geração de poemas ou outras tarefas criativas, pode ser benéfico aumentar o valor da temperatura.
 
-**Top_p** - Da mesma forma, com `top_p`, uma técnica de amostragem com temperatura chamada amostragem de núcleo, você pode controlar o grau de determinismo do modelo na geração de uma resposta. Se você está procurando respostas exatas e factuais, mantenha isso baixo. Se você estiver procurando respostas mais diversificadas, aumente para um valor mais alto.
+**Top_p** - Da mesma forma, com o `top_p`, uma técnica de amostragem com temperatura chamada amostragem de núcleo, você pode controlar o grau de determinismo do modelo na geração de uma resposta. Se você está procurando respostas exatas e factuais, mantenha isso baixo. Se você estiver procurando respostas mais diversificadas, aumente para um valor mais alto.
 
 A recomendação geral é alterar um, não ambos.
 

pages/introduction/tips.pt.mdx

@@ -29,13 +29,13 @@ Texto: "olá!"
 
 *Saída:*
 ```
-Olá!
+¡Hola!
 ```
 
 ### Especificidade
 Seja muito específico sobre a instrução e a tarefa que deseja que o modelo execute. Quanto mais descritivo e detalhado for o prompt, melhores serão os resultados. Isso é particularmente importante quando você tem um resultado desejado ou estilo de geração que está buscando. Não há tokens ou palavras-chave específicas que levem a melhores resultados. É mais importante ter um bom formato e um prompt descritivo. Na verdade, fornecer exemplos no prompt é muito eficaz para obter a saída desejada em formatos específicos.
 
-Ao criar prompts, você também deve ter em mente o comprimento do prompt, pois há limitações em relação a quanto tempo isso pode durar. Pensar em quão específico e detalhado você deve ser é algo a se considerar. Incluir muitos detalhes desnecessários não é necessariamente uma boa abordagem. Os detalhes devem ser relevantes e contribuir para a tarefa em mãos. Isso é algo que você precisará experimentar muito. Incentivamos muita experimentação e iteração para otimizar os prompts de seus aplicativos.
+Ao criar prompts, você também deve ter em mente o tamanho do prompt, pois há limitações em relação a quão grande ele pode ser. Pensar em quão específico e detalhado você deve ser é algo a se considerar. Incluir muitos detalhes desnecessários não é necessariamente uma boa abordagem. Os detalhes devem ser relevantes e contribuir para a tarefa em mãos. Isso é algo que você precisará experimentar muito. Incentivamos muita experimentação e iteração para otimizar os prompts de seus aplicativos.
 
 Como exemplo, vamos tentar um prompt simples para extrair informações específicas de um texto.
 
@@ -44,9 +44,9 @@ Como exemplo, vamos tentar um prompt simples para extrair informações específ
 Extraia o nome dos lugares no texto a seguir.
 
 Formato desejado:
-Local: <comma_separated_list_of_company_names>
+Local: <lista_separada_por_vírgulas_de_nomes_de_empresas>
 
-Contribuição: "Embora estes desenvolvimentos sejam encorajadores para os investigadores, muito ainda é um mistério. “Muitas vezes temos uma caixa preta entre o cérebro e o efeito que vemos na periferia”, diz Henrique Veiga-Fernandes, neuroimunologista do Centro Champalimaud de o Desconhecido em Lisboa. “Se queremos utilizá-lo no contexto terapêutico, precisamos de facto de perceber o mecanismo.""
+Input: "Embora estes desenvolvimentos sejam encorajadores para os investigadores, muito ainda é um mistério. “Muitas vezes temos uma caixa preta entre o cérebro e o efeito que vemos na periferia”, diz Henrique Veiga-Fernandes, neuroimunologista do Centro Champalimaud para o Desconhecido em Lisboa. “Se queremos utilizá-lo no contexto terapêutico, precisamos de facto de perceber o mecanismo."
 ```
 
 *Saída:*
@@ -54,7 +54,7 @@ Contribuição: "Embora estes desenvolvimentos sejam encorajadores para os inves
 Local: Centro Champalimaud para o Desconhecido, Lisboa
 ```
 
-O texto de entrada é obtido de [este artigo da Nature](https://www.nature.com/articles/d41586-023-00509-z).
+O texto de entrada é obtido [neste artigo da Nature](https://www.nature.com/articles/d41586-023-00509-z).
 
 ### Evite Imprecisões
 
@@ -63,13 +63,13 @@ Dadas as dicas acima sobre como ser detalhado e melhorar o formato, é fácil ca
 Por exemplo, você pode estar interessado em aprender o conceito de engenharia de prompt. Você pode tentar algo como:
 
 ```
-Explique o conceito de engenharia imediata. Mantenha a explicação curta, apenas algumas frases, e não seja muito descritivo.
+Explique o conceito de engenharia de prompt. Mantenha a explicação curta, apenas algumas frases, e não seja muito descritivo.
 ```
 
-Não está claro no prompt acima quantas frases usar e qual estilo. Você ainda pode obter boas respostas com os prompts acima, mas o melhor prompt seria aquele que é muito específico, conciso e direto ao ponto. Algo como:
+Não está claro no prompt acima quantas frases usar e qual estilo. Você ainda pode obter uma boa resposta com o prompt acima, mas o melhor prompt seria aquele que é muito específico, conciso e direto ao ponto. Algo como:
 
 ```
-Use 2 a 3 frases para explicar o conceito de engenharia imediata a um aluno do ensino médio.
+Use 2 a 3 frases para explicar o conceito de engenharia de prompt a um aluno do ensino médio.
 ```
 
 ### Fazer ou não fazer?
@@ -79,7 +79,7 @@ Aqui está um exemplo de um chatbot de recomendação de filme falhando exatamen
 
 *Prompt:*
 ```
-O seguinte é um agente que recomenda filmes a um cliente. NÃO PEÇA INTERESSES. NÃO PEÇA INFORMAÇÕES PESSOAIS.
+O agente a seguir recomenda filmes para um cliente. NÃO PEÇA INTERESSES. NÃO PEÇA INFORMAÇÕES PESSOAIS.
 
 Cliente: Por favor, recomende um filme baseado nos meus interesses.
 Agente:
@@ -94,7 +94,7 @@ Aqui está um prompt melhor:
 
 *Prompt:*
 ```
-O seguinte é um agente que recomenda filmes a um cliente. O agente é responsável por recomendar um filme dos principais filmes de tendências globais. Deve abster-se de perguntar aos usuários sobre suas preferências e evitar pedir informações pessoais. Se o agente não tiver um filme para recomendar, ele deve responder "Desculpe, não foi possível encontrar um filme para recomendar hoje.".
+O agente a seguir recomenda filmes para um cliente. O agente é responsável por recomendar um filme dos principais filmes de tendências globais. Deve abster-se de perguntar aos usuários sobre suas preferências e evitar pedir informações pessoais. Se o agente não tiver um filme para recomendar, ele deve responder "Desculpe, não foi possível encontrar um filme para recomendar hoje.".
 
 Cliente: Por favor, recomende um filme baseado nos meus interesses.
 Agente:

pages/introduction/tips.zh.mdx

@@ -50,7 +50,7 @@
 
 *输出：*
 ```
-地点：里斯本未知的香帕利莫德中心
+地点：里斯本，香帕利莫德中心
 ```
 
 输入文本来自[这篇Nature文章](https://www.nature.com/articles/d41586-023-00509-z)。

pages/models/collection.jp.mdx

@@ -1,32 +1,32 @@
-# Model Collection
+# モデル一覧
 
 import { Callout, FileTree } from 'nextra-theme-docs'
 
 <Callout emoji="⚠️">
-  This section is under heavy development.
+  このセクションの内容は、鋭意開発進行中です。
 </Callout>
 
-This section consists of a collection and summary of notable and foundational LLMs. (Data adopted from [Papers with Code](https://paperswithcode.com/methods/category/language-models) and the recent work by [Zhao et al. (2023)](https://arxiv.org/pdf/2303.18223.pdf).
+このセクションには、注目すべきLLMの基礎技術(モデル)の一覧とその概要をまとめています([Papers with Code](https://paperswithcode.com/methods/category/language-models)と[Zhao et al. (2023)](https://arxiv.org/pdf/2303.18223.pdf) による直近の研究成果を元に一覧を作成しています)。
 
 ## Models
 
-| Model | Release Date | Description | 
+| モデル名 | 発表された年 | 概要説明 | 
 | --- | --- | --- | 
-| [BERT](https://arxiv.org/abs/1810.04805)| 2018 | Bidirectional Encoder Representations from Transformers | 
+| [BERT](https://arxiv.org/abs/1810.04805)| 2018 | Transformer による双方向(Bidirectional)エンコーダーの特徴表現を利用したモデル | 
-| [GPT](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf) | 2018 | Improving Language Understanding by Generative Pre-Training | 
+| [GPT](https://s3-us-west-2.amazonaws.com/openai-assets/research-covers/language-unsupervised/language_understanding_paper.pdf) | 2018 | 事前学習を利用した生成モデルにより、自然言語の理解を進展させた | 
-| [RoBERTa](https://arxiv.org/abs/1907.11692) | 2019 | A Robustly Optimized BERT Pretraining Approach | 
+| [RoBERTa](https://arxiv.org/abs/1907.11692) | 2019 | 頑健性(Robustness)を重視して BERT を最適化する事前学習のアプローチ | 
-| [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) | 2019 | Language Models are Unsupervised Multitask Learners | 
+| [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) | 2019 | 自然言語モデルが、教師なし学習によってマルチタスクをこなせるようになるということを実証 | 
-| [T5](https://arxiv.org/abs/1910.10683) | 2019 | Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer | 
+| [T5](https://arxiv.org/abs/1910.10683) | 2019 | フォーマットを統一した Text-to-Text Transformer を用いて、転移学習の限界を探索 | 
-| [BART](https://arxiv.org/abs/1910.13461) | 2019 | Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension |
+| [BART](https://arxiv.org/abs/1910.13461) | 2019 | 自然言語の生成、翻訳、理解のために、 Sequence-to-Sequence な事前学習モデルのノイズを除去した |
-| [ALBERT](https://arxiv.org/abs/1909.11942) |2019 | A Lite BERT for Self-supervised Learning of Language Representations | 
+| [ALBERT](https://arxiv.org/abs/1909.11942) | 2019 | 言語表現を自己教師学習するための BERT 軽量(Lite)化モデル | 
-| [XLNet](https://arxiv.org/abs/1906.08237) | 2019 | Generalized Autoregressive Pretraining for Language Understanding and Generation |
+| [XLNet](https://arxiv.org/abs/1906.08237) | 2019 | 自然言語の理解と生成のための自己回帰事前学習の一般化 |
-| [CTRL](https://arxiv.org/abs/1909.05858) |2019 | CTRL: A Conditional Transformer Language Model for Controllable Generation | 
+| [CTRL](https://arxiv.org/abs/1909.05858) | 2019 | CTRL: 生成モデルをコントロール可能にするための、条件付き Transformer 言語モデル | 
-| [ERNIE](https://arxiv.org/abs/1904.09223v1) | 2019| ERNIE: Enhanced Representation through Knowledge Integration |
+| [ERNIE](https://arxiv.org/abs/1904.09223v1) | 2019 | ERNIE: 知識の統合を通じて特徴表現を高度化 |
-| [GShard](https://arxiv.org/abs/2006.16668v1) | 2020 | GShard: Scaling Giant Models with Conditional Computation and Automatic Sharding |
+| [GShard](https://arxiv.org/abs/2006.16668v1) | 2020 | GShard: 条件付き演算と自動シャーディング(Sharding)を用いた巨大モデルのスケーリング |
-| [GPT-3](https://arxiv.org/abs/2005.14165) | 2020 | Language Models are Few-Shot Learners |
+| [GPT-3](https://arxiv.org/abs/2005.14165) | 2020 | 自然言語モデルが、 Few-Shot で十分学習できるということを実証 |
-| [LaMDA](https://arxiv.org/abs/2201.08239v3) | 2021 | LaMDA: Language Models for Dialog Applications | 
+| [LaMDA](https://arxiv.org/abs/2201.08239v3) | 2021 | LaMDA: 対話(Dialogue)アプリケーションのための自然言語モデル | 
-| [PanGu-α](https://arxiv.org/abs/2104.12369v1) | 2021 | PanGu-α: Large-scale Autoregressive Pretrained Chinese Language Models with Auto-parallel Computation |
+| [PanGu-α](https://arxiv.org/abs/2104.12369v1) | 2021 | PanGu-α: 自動並列演算を用いて自己回帰事前学習された、中国語大規模言語モデル |
-| [mT5](https://arxiv.org/abs/2010.11934v3) | 2021 | mT5: A massively multilingual pre-trained text-to-text transformer |
+| [mT5](https://arxiv.org/abs/2010.11934v3) | 2021 | mT5: 多言語で大規模に事前学習された text-to-text transformer |
 | [CPM-2](https://arxiv.org/abs/2106.10715v3) | 2021 | CPM-2: Large-scale Cost-effective Pre-trained Language Models |
 | [T0](https://arxiv.org/abs/2110.08207) |2021 |Multitask Prompted Training Enables Zero-Shot Task Generalization |
 | [HyperCLOVA](https://arxiv.org/abs/2109.04650) | 2021 | What Changes Can Large-scale Language Models Bring? Intensive Study on HyperCLOVA: Billions-scale Korean Generative Pretrained Transformers |
@@ -37,8 +37,8 @@ This section consists of a collection and summary of notable and foundational LL
 | [MT-NLG](https://arxiv.org/abs/2201.11990v3) | 2021 | Using DeepSpeed and Megatron to Train Megatron-Turing NLG 530B, A Large-Scale Generative Language Model|
 | [Yuan 1.0](https://arxiv.org/abs/2110.04725v2) | 2021| Yuan 1.0: Large-Scale Pre-trained Language Model in Zero-Shot and Few-Shot Learning |
 | [WebGPT](https://arxiv.org/abs/2112.09332v3) | 2021 | WebGPT: Browser-assisted question-answering with human feedback |
-| [Gopher](https://arxiv.org/abs/2112.11446v2) |2021 | Scaling Language Models: Methods, Analysis & Insights from Training Gopher |
+| [Gopher](https://arxiv.org/abs/2112.11446v2) | 2021 | Scaling Language Models: Methods, Analysis & Insights from Training Gopher |
-| [ERNIE 3.0 Titan](https://arxiv.org/abs/2112.12731v1) |2021 | ERNIE 3.0 Titan: Exploring Larger-scale Knowledge Enhanced Pre-training for Language Understanding and Generation |
+| [ERNIE 3.0 Titan](https://arxiv.org/abs/2112.12731v1) | 2021 | ERNIE 3.0 Titan: Exploring Larger-scale Knowledge Enhanced Pre-training for Language Understanding and Generation |
 | [GLaM](https://arxiv.org/abs/2112.06905) | 2021 | GLaM: Efficient Scaling of Language Models with Mixture-of-Experts |
 | [InstructGPT](https://arxiv.org/abs/2203.02155v1) | 2022 | Training language models to follow instructions with human feedback |
 | [GPT-NeoX-20B](https://arxiv.org/abs/2204.06745v1) | 2022 | GPT-NeoX-20B: An Open-Source Autoregressive Language Model |
@@ -47,7 +47,7 @@ This section consists of a collection and summary of notable and foundational LL
 | [Chinchilla](https://arxiv.org/abs/2203.15556) | 2022 | Shows that for a compute budget, the best performances are not achieved by the largest models but by smaller models trained on more data. |
 | [Tk-Instruct](https://arxiv.org/abs/2204.07705v3) | 2022 | Super-NaturalInstructions: Generalization via Declarative Instructions on 1600+ NLP Tasks |
 | [UL2](https://arxiv.org/abs/2205.05131v3) | 2022 | UL2: Unifying Language Learning Paradigms |
-| [PaLM](https://arxiv.org/abs/2204.02311v5) |2022| PaLM: Scaling Language Modeling with Pathways |
+| [PaLM](https://arxiv.org/abs/2204.02311v5) | 2022 | PaLM: Scaling Language Modeling with Pathways |
 | [OPT](https://arxiv.org/abs/2205.01068) | 2022 | OPT: Open Pre-trained Transformer Language Models |
 | [BLOOM](https://arxiv.org/abs/2211.05100v3) | 2022 | BLOOM: A 176B-Parameter Open-Access Multilingual Language Model |
 | [GLM-130B](https://arxiv.org/abs/2210.02414v1) | 2022 | GLM-130B: An Open Bilingual Pre-trained Model |
@@ -59,6 +59,6 @@ This section consists of a collection and summary of notable and foundational LL
 | [Galactica](https://arxiv.org/abs/2211.09085v1) | 2022 | Galactica: A Large Language Model for Science |
 | [OPT-IML](https://arxiv.org/abs/2212.12017v3) | 2022 | OPT-IML: Scaling Language Model Instruction Meta Learning through the Lens of Generalization |
 | [LLaMA](https://arxiv.org/abs/2302.13971v1) | 2023 | LLaMA: Open and Efficient Foundation Language Models |
-| [GPT-4](https://arxiv.org/abs/2303.08774v3) | 2023 |GPT-4 Technical Report |
+| [GPT-4](https://arxiv.org/abs/2303.08774v3) | 2023 | GPT-4 Technical Report |
 | [PanGu-Σ](https://arxiv.org/abs/2303.10845v1) | 2023 | PanGu-Σ: Towards Trillion Parameter Language Model with Sparse Heterogeneous Computing |
-| [BloombergGPT](https://arxiv.org/abs/2303.17564v1)| 2023 |BloombergGPT: A Large Language Model for Finance|
+| [BloombergGPT](https://arxiv.org/abs/2303.17564v1)| 2023 |BloombergGPT: A Large Language Model for Finance |

pages/readings.en.mdx

@@ -44,6 +44,7 @@
 - [Giving GPT-3 a Turing Test](https://lacker.io/ai/2020/07/06/giving-gpt-3-a-turing-test.html)
 - [GPT-3 & Beyond](https://youtube.com/watch?v=-lnHHWRCDGk)
 - [GPT3 and Prompts: A quick primer](https://buildspace.so/notes/intro-to-gpt3-prompts)
+- [GPT-4 Tutorial: How to Chat With Multiple PDF Files (~1000 pages of Tesla's 10-K Annual Reports)](https://youtu.be/Ix9WIZpArm0)
 - [Hands-on with Bing’s new ChatGPT-like features](https://techcrunch.com/2023/02/08/hands-on-with-the-new-bing/)
 - [How to Draw Anything](https://andys.page/posts/how-to-draw)
 - [How to get images that don't suck](https://www.reddit.com/r/StableDiffusion/comments/x41n87/how_to_get_images_that_dont_suck_a)

pages/style.css

@@ -0,0 +1 @@
+pre { white-space: pre-wrap; }

pages/techniques/react.en.mdx

@@ -1,14 +1,179 @@
-# ReAct
+# ReAct Prompting
 
 import { Callout, FileTree } from 'nextra-theme-docs'
 import {Screenshot} from 'components/screenshot'
 import REACT from '../../img/react.png'
+import REACT1 from '../../img/react/table1.png'
+import REACT2 from '../../img/react/alfworld.png'
 
-[Yao et al., 2022](https://arxiv.org/abs/2210.03629) introduced a framework where LLMs are used to generate both reasoning traces and task-specific actions in an interleaved manner. Generating reasoning traces allow the model to induce, track, and update action plans, and even handle exceptions. The action step allows to interface with and gather information from external sources such as knowledge bases or environments.
+[Yao et al., 2022](https://arxiv.org/abs/2210.03629) introduced a framework named ReAct where LLMs are used to generate both *reasoning traces* and *task-specific actions* in an interleaved manner. 
+
+Generating reasoning traces allow the model to induce, track, and update action plans, and even handle exceptions. The action step allows to interface with and gather information from external sources such as knowledge bases or environments.
 
 The ReAct framework can allow LLMs to interact with external tools to retrieve additional information that leads to more reliable and factual responses.
 
+Results show that ReAct can outperform several state-of-the-art baselines on language and decision-making tasks. ReAct also leads to improved human interpretability and trustworthiness of LLMs. Overall, the authors found that best approach uses ReAct combined with chain-of-thought (CoT) that allows use of both internal knowledge and external information obtained during reasoning. 
+
+
+## How it Works?
+
+ReAct is inspired by the synergies between "acting" and "reasoning" which allow humans to learn new tasks and make decisions or reasoning. 
+
+Chain-of-thought (CoT) prompting has shown the capabilities of LLMs to carry out reasoning traces to generate answers to questions involving arithmetic and commonsense reasoning, among other tasks [(Wei et al., 2022)](https://arxiv.org/abs/2201.11903). But it's lack of access to the external world or inability to update its knowledge can lead to issues like fact hallucination and error propagation. 
+
+ReAct is a general paradigm that combines reasoning and acting with LLMs. ReAct prompts LLMs to generate verbal reasoning traces and actions for a task. This allows the system to perform dynamic reasoning to create, maintain, and adjust plans for acting while also enabling interaction to external environments (e.g., Wikipedia) to incorporate additional information into the reasoning. The figure below shows an example of ReAct and the different steps involved to perform question answering.
+
 <Screenshot src={REACT} alt="REACT" />
 Image Source: [Yao et al., 2022](https://arxiv.org/abs/2210.03629)
 
-Full example coming soon!
+In the example above, we pass a prompt like the following question from [HotpotQA](https://hotpotqa.github.io/):
+
+```
+Aside from the Apple Remote, what other devices can control the program Apple Remote was originally designed to interact with?
+```
+
+Note that in-context examples are also added to the prompt but we exclude that here for simplicity. We can see that the model generates *task solving trajectories* (Thought, Act). Obs corresponds to observation from the environment that's being interacted with (e.g., Search engine). In essence, ReAct can retrieve information to support reasoning, while reasoning helps to target what to retrieve next.  
+
+## ReAct Prompting
+To demonstrate how ReAct prompting works, let's follow an example from the paper. 
+
+The first step is to select cases from a training set (e.g., HotPotQA) and compose ReAct-format trajectories. These are used as few-shot exemplars in the prompts. The trajectories consist of multiple thought-action-observation steps as shown in the figure above. The free-form thoughts are used to achieve different tasks such as decomposing questions, extracting information, performing commonsense/arithmetic reasoning, guide search formulation, and synthesizing final answer. 
+
+Here is an example of what the ReAct prompt exemplars look like (obtained from the paper and shortened to one example for simplicity): 
+
+```
+Question What is the elevation range for the area that the eastern sector of the
+Colorado orogeny extends into?
+Thought 1 I need to search Colorado orogeny, find the area that the eastern sector
+of the Colorado orogeny extends into, then find the elevation range of the
+area.
+Action 1 Search[Colorado orogeny]
+Observation 1 The Colorado orogeny was an episode of mountain building (an orogeny) in
+Colorado and surrounding areas.
+Thought 2 It does not mention the eastern sector. So I need to look up eastern
+sector.
+Action 2 Lookup[eastern sector]
+Observation 2 (Result 1 / 1) The eastern sector extends into the High Plains and is called
+the Central Plains orogeny.
+Thought 3 The eastern sector of Colorado orogeny extends into the High Plains. So I
+need to search High Plains and find its elevation range.
+Action 3 Search[High Plains]
+Observation 3 High Plains refers to one of two distinct land regions
+Thought 4 I need to instead search High Plains (United States).
+Action 4 Search[High Plains (United States)]
+Observation 4 The High Plains are a subregion of the Great Plains. From east to west, the
+High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130
+m).[3]
+Thought 5 High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer
+is 1,800 to 7,000 ft.
+Action 5 Finish[1,800 to 7,000 ft]
+...
+```
+
+Note that different prompts setups are used for different types of tasks. For tasks where reasoning is of primary importance (e.g., HotpotQA), multiple thought-action-observation steps are used for the task-solving trajectory. For decision making tasks involving lots of action steps, thoughts are used sparsely.  
+
+## Results on Knowledge-Intensive Tasks
+
+The paper first evaluates ReAct on knowledge-intensive reasoning tasks such as question answering (HotPotQA) and fact verification ([Fever](https://fever.ai/resources.html)). PaLM-540B is used as the base model for prompting. 
+
+<Screenshot src={REACT1} alt="REACT1" />
+Image Source: [Yao et al., 2022](https://arxiv.org/abs/2210.03629)
+
+The prompting results on HotPotQA and Fever using different prompting methods show that ReAct generally performs better than Act (involves acting only) on both tasks. 
+
+We can also observe that ReAct outperforms CoT on Fever and lags behind CoT on HotpotQA. A detailed error analysis is provided in the paper. In summary:
+
+- CoT suffers from fact hallucination
+- ReAct's structural constraint reduces its flexibility in formulating reasoning steps
+- ReAct depends a lot on the information it's retrieving; non-informative search results derails the model reasoning and leads to difficulty in recovering and reformulating thoughts
+
+Prompting methods that combine and support switching between ReAct and CoT+Self-Consistency generally outperform all the other prompting methods. 
+
+## Results on Knowledge-Intensive Tasks
+
+The paper also reports results demonstrating ReAct's performance on decision making tasks. ReAct is evaluated on two benchmarks called [ALFWorld](https://alfworld.github.io/) (text-based game) and [WebShop](https://webshop-pnlp.github.io/) (online shopping website environment). Both involve complex environments that require reasoning to act and explore effectively. 
+
+Note that the ReAct prompts are designed differently for these tasks while still keeping the same core idea of combining reasoning and acting. Below is an example for an ALFWorld problem involving ReAct prompting. 
+
+<Screenshot src={REACT2} alt="REACT2" />
+Image Source: [Yao et al., 2022](https://arxiv.org/abs/2210.03629)
+
+ReAct outperforms Act on both ALFWorld and Webshop. Act, without any thoughts, fails to correctly decompose goals into subgoals. Reasoning seems to be advantageous in ReAct for these types of tasks but current prompting-based methods are still far from the performance of expert humans on these tasks. 
+
+Check out the paper for more detailed results.
+
+## LangChain ReAct Usage
+
+Below is a high-level example of how the ReAct prompting approach works in practice. We will be using OpenAI for the LLM and [LangChain](https://python.langchain.com/en/latest/index.html) as it already has built-in functionality that leverages the ReAct framework to build agents that perform tasks by combining the power of LLMs and different tools. 
+
+First, let's install and import the necessary libraries:
+
+``` python
+%%capture
+# update or install the necessary libraries
+!pip install --upgrade openai
+!pip install --upgrade langchain
+!pip install --upgrade python-dotenv
+!pip install google-search-results
+
+# import libraries
+import openai
+import os
+from langchain.llms import OpenAI
+from langchain.agents import load_tools
+from langchain.agents import initialize_agent
+from dotenv import load_dotenv
+load_dotenv()
+
+# load API keys; you will need to obtain these if you haven't yet
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
+os.environ["SERPAPI_API_KEY"] = os.getenv("SERPAPI_API_KEY")
+
+```
+
+Now we can configure the LLM, the tools we will use, and the agent that allows us to leverage the ReAct framework together with the LLM and tools. Note that we are using a search API for searching external information and LLM as a math tool. 
+
+``` python
+llm = OpenAI(model_name="text-davinci-003" ,temperature=0)
+tools = load_tools(["serpapi", "llm-math"], llm=llm)
+agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)
+```
+
+Once that's configured, we can now run the agent with the desired query/prompt. Notice that here we are not expected to provide few-shot exemplars as explained in the paper. 
+
+``` python
+agent.run("Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?")
+```
+
+The chain execution looks as follows:
+
+``` yaml
+> Entering new AgentExecutor chain...
+ I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power.
+Action: Search
+Action Input: "Olivia Wilde boyfriend"
+Observation: Olivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.
+Thought: I need to find out Harry Styles' age.
+Action: Search
+Action Input: "Harry Styles age"
+Observation: 29 years
+Thought: I need to calculate 29 raised to the 0.23 power.
+Action: Calculator
+Action Input: 29^0.23
+Observation: Answer: 2.169459462491557
+
+Thought: I now know the final answer.
+Final Answer: Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557.
+
+> Finished chain.
+```
+
+The output we get is as follows:
+
+```
+"Harry Styles, Olivia Wilde's boyfriend, is 29 years old and his age raised to the 0.23 power is 2.169459462491557."
+```
+
+We adapted the example from the [LangChain documentation](https://python.langchain.com/en/latest/modules/agents/getting_started.html), so credit goes to them. We encourage the learner to explore different combination of tools and tasks. 
+
+You can find the notebook for this code here: https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/notebooks/react.ipynb

pages/tools.en.mdx

@@ -16,6 +16,7 @@
 - [Interactive Composition Explorer](https://github.com/oughtinc/ice)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Lexica](https://lexica.art)
+- [LMFlow](https://github.com/OptimalScale/LMFlow)
 - [loom](https://github.com/socketteer/loom)
 - [Metaprompt](https://metaprompt.vercel.app/?task=gpt)
 - [OpenAI Playground](https://beta.openai.com/playground)

pages/tools.jp.mdx

@@ -15,6 +15,7 @@
 - [Interactive Composition Explorer](https://github.com/oughtinc/ice)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Lexica](https://lexica.art)
+- [LMFlow](https://github.com/OptimalScale/LMFlow)
 - [loom](https://github.com/socketteer/loom)
 - [Metaprompt](https://metaprompt.vercel.app/?task=gpt)
 - [OpenAI Playground](https://beta.openai.com/playground)

pages/tools.pt.mdx

@@ -16,6 +16,7 @@
 - [Interactive Composition Explorer](https://github.com/oughtinc/ice)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Lexica](https://lexica.art)
+- [LMFlow](https://github.com/OptimalScale/LMFlow)
 - [loom](https://github.com/socketteer/loom)
 - [Metaprompt](https://metaprompt.vercel.app/?task=gpt)
 - [OpenAI Playground](https://beta.openai.com/playground)

pages/tools.tr.mdx

@@ -16,6 +16,7 @@
 - [Interactive Composition Explorer](https://github.com/oughtinc/ice)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Lexica](https://lexica.art)
+- [LMFlow](https://github.com/OptimalScale/LMFlow)
 - [loom](https://github.com/socketteer/loom)
 - [Metaprompt](https://metaprompt.vercel.app/?task=gpt)
 - [OpenAI Playground](https://beta.openai.com/playground)

pages/tools.zh.mdx

@@ -16,6 +16,7 @@
 - [Interactive Composition Explorer](https://github.com/oughtinc/ice)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Lexica](https://lexica.art)
+- [LMFlow](https://github.com/OptimalScale/LMFlow)
 - [loom](https://github.com/socketteer/loom)
 - [Metaprompt](https://metaprompt.vercel.app/?task=gpt)
 - [OpenAI Playground](https://beta.openai.com/playground)