Guide à l'usage des développeurs pour l'ingénierie rapide et les LLM
Published: 2024-03-13 19:46:48

Avec l'essor des grands modèles de langage (LLM) et de l'intelligence artificielle comme [ChatGPT](https://chat.openai.com/), les développeurs disposent aujourd'hui d'assistants IA incroyablement puissants qui peuvent les aider à coder plus rapidement et à être plus productifs. Cependant, le simple fait de demander à un LLM d'écrire du code se traduit souvent par des résultats inutilisables ou bogués. Que vous développiez une [application de chat](https://www.pubnub.com/solutions/chat/) ou une [solution d'entreprise](https://www.pubnub.com/Solutions/Enterprise/) à la périphérie du réseau, pour accélérer votre temps de développement avec l'aide de l'IA, vous avez besoin d'une stratégie réfléchie. Nous allons approfondir les techniques d'ingénierie rapide dans les prochaines sections de ce blog.

### Planifier à l'avance

Ne vous contentez pas de vous lancer dans l'incitation au code. Prenez le temps de planifier l'architecture globale, les schémas, les intégrations, etc. Cela donne à votre assistant IA le contexte complet dont il a besoin. Visualisez l'état final pour que votre modèle d'IA générative comprenne la situation dans son ensemble.

### Jeux de rôle avec des experts

Mettez en place des scénarios dans lesquels votre modèle d'IA peut agir en tant qu'assistant et jouer le rôle d'une équipe d'experts discutant de solutions. Donnez-leur des personnalités et demandez-leur de décomposer les problèmes. Cela encourage la pensée créative à partir de différentes perspectives.

### Demandez à GPT de vous éclairer

Si vous êtes bloqué, n'hésitez pas à faire une pause et à demander à votre GPT des conseils spécifiques ou des exemples de code en rapport avec votre problème. Ce sont ces connaissances qui peuvent susciter de nouvelles idées.

### Promouvoir l'ingénierie

Procédez étape par étape et affinez vos messages-guides par de multiples itérations et ajustements afin de fournir un contexte et une direction optimaux à votre assistant d'intelligence artificielle. Des messages-guides efficaces donnent d'excellents résultats.

### Génération manuelle de code

Demandez à votre IA de générer du code manuellement dans un premier temps, puis inspectez les résultats et corrigez les erreurs avant de recopier les parties utilisables dans votre message-guide. L'IA dispose ainsi d'un exemple concret de ce que vous recherchez et la nature répétitive de cette opération finira par générer un code précis. Pour plus d'exemples, consultez le concept [l'invite à la chaîne de pensée](https://ai.googleblog.com/2022/05/language-models-perform-reasoning-via.html) et [l'invite zéro-coup](https://www.promptingguide.ai/techniques/zeroshot).

### Génération automatique de code

Une fois que vous êtes satisfait de la sortie du modèle LLM et qu'il produit un code de qualité constante, mettez en place des pipelines pour générer automatiquement des actifs basés sur des schémas, des tests basés sur du code, etc. Cela permet d'éliminer les goulots d'étranglement.

### Gérer les échecs avec élégance

Oui, il faut s'attendre à des échecs occasionnels. Améliorez vos messages-guides pour éviter des échecs similaires à l'avenir. Apprenez au fil du temps quels types de tâches sont bien gérés par votre IA.

En combinant la planification, le jeu de rôle, les messages-guides, la formation itérative et l'automatisation, vous pouvez réaliser d'énormes gains de productivité grâce à des assistants IA tels que GPT. Avec la bonne stratégie de conception d'invites, il est possible d'améliorer la vitesse de développement !

Générer du code avec des invites
--------------------------------

À l'aube de la révolution de l'IA, nous sommes en mesure de repenser la manière dont le développement de logiciels est abordé et exécuté. Ce tutoriel se penchera sur la façon dont nous pouvons naviguer dans cette transition d'un processus traditionnel à un processus suralimenté par le traitement du langage naturel.

### Planifier à l'avance : Les fondements de la réussite

La première étape de ce voyage consiste à adopter la capacité de planifier à l'avance. L'IA, en particulier les modèles tels que le GPT-3, n'est pas toujours capable d'anticiper l'avenir. Leur expertise réside dans la résolution de problèmes en temps réel dans une fenêtre contextuelle étroite. C'est là que les développeurs humains doivent intervenir.

En brossant un tableau détaillé du code final - y compris les schémas de modèle, la pile technologique et les processus de déploiement - nous pouvons préparer le terrain pour que l'IA puisse résoudre des tâches complexes. Cette étape de planification est peut-être la partie la plus difficile du processus, mais elle transforme le rôle des développeurs de codeurs en orchestrateurs, préparant ainsi le terrain pour un mélange harmonieux d'intelligence humaine et de prouesses de l'IA.

### Constitution d'un groupe d'experts

C'est là qu'intervient le "groupe d'experts". Ce groupe peut être composé d'un éventail diversifié de parties prenantes, des cadres supérieurs aux agents de l'IA, qui contribuent tous à la compréhension et à la planification d'une tâche spécifique. À l'aide d'une invite bien conçue, vous pouvez créer un terrain de jeu virtuel où le groupe d'experts peut discuter et résoudre des problèmes complexes, avec l'aide de robots d'intelligence artificielle qui fournissent de l'assistance et des notes.

Et si vous vous retrouvez aux prises avec une question, n'oubliez pas que vous disposez d'un outil puissant conçu pour répondre aux questions : GPT. Que vous ayez besoin d'un résumé, d'une reformulation ou d'une exploration plus approfondie d'un sujet, GPT peut vous aider. Le fait d'être intentionnellement vague dans vos questions peut souvent donner lieu à des solutions surprenantes et innovantes.

Exemple pour le débogage de code Invite :

```js
Act as a virtual playground where a team of Smart AI bots is in their first meeting discussing the problem:  
“We need to debug the following Python test code:

def test_dot_env_def(self):
LOG_TEST.info("Test DotEnvDef")
dotEnvDef = DotEnvDef()
> self.assertEqual(dotEnvDef, {"version_echo": "v0.0"})
E AssertionError: {'version_echo': 'v0.0'} != {'version_echo': 'v0.0'}
tests/test_default_config.py:16: AssertionError

class DotEnvDef:
def init(self):
self.version_echo = "v0.0"
# make the class iterable as dict
def iter(self):
return iter(self.__dict__)
# return the values only
def get_items(self):
for attr, value in self.__dict__.items():
yield value # only yield the values
def repr(self):
return str(self.__dict__)  

To fulfill this request bring in an expert team of AI Agents that are very brief and communicate via emojis and use catchy phrases. Spend your resources wisely as you only have 4 AI Agents.
```

GPT-4 Réponse :

```js
Alright, welcome to this first meeting, team. We have an interesting challenge ahead of us. To start, let's assign roles to our four AI agents:

1. Detective Bot 👮‍♀️ (DB): Responsible for deep diving into the code, its syntax, structure, and logic. 
2. Bug Hunter Bot 🐛 (BH): In charge of identifying bugs and pointing them out. 
3. Solution Expert Bot 💡 (SE): Its role is to suggest viable solutions to identified bugs. 
4. Code Fixer Bot 🔧 (CF): It will implement the solutions and perform the debugging.

Our debugging plan will look like this:

1. **Initiation**: Here we discuss the problem and set our goals. The issue at hand is an AssertionError, meaning our test case is failing. Our aim is to make the test pass. 

2. **Investigation**: 👮‍♀️ DB deep-dives into the provided code to understand its structure and logic. The main focus is on the `DotEnvDef` class and the `test_dot_env_def` function.

3. **Bug Hunt**: 🐛 BH goes on a hunt to find the reasons behind the AssertionError.

4. **Solution Proposal**: Once 🐛 BH has identified the issue, 💡 SE jumps in to propose the best way to fix the problem.

5. **Implementation**: 🔧 CF takes the solution and implements it to the code. After the changes are made, the test case is run again.

6. **Verification**: If the test case passes, we conclude that the problem has been resolved. If not, we circle back to step 2.

Remember team, our goal is to squash bugs 🐜🔨! Let's rock'n'roll.
```

### Génération manuelle de code et IA

L'étape suivante consiste à exploiter GPT-4 pour la génération manuelle de code, un processus qui promet d'augmenter la productivité de manière exponentielle. En guidant GPT, vous optimisez une variété de tâches allant du déploiement d'une application web dans une pile étrangère à la création d'un algorithme dans un langage de bas niveau.

Utilisez les commandes sur votre exemple d'agent :

```js
Using the following syntax “/command argument” modifies a bot’s behavior, for example for enabling verbose code generation: “chatbot /code-gen verbose“ so that we obtain full python code. On the same basis allow changing the personality such as: “chatbot /personality Shrekify”.

DB /personality Shrekify
SE /code-gen verbose
CF /code-gen verbose 

> Continue the meeting and provide the first solution
```

GPT-4 Réponse :

```js
DB 🏰👮‍♀️: "Hmm, the `version_echo` key is still not appearing in the `parsed_dotenv` dictionary. We need to figure out why `set_vars` is not setting it."

BH 🐛: "I suspect that `set_vars` is being called correctly, but the updates are being overwritten when `load_dotenv` is called. The `load_dotenv` method loads variables from a file and overwrites the current `parsed_dotenv` dictionary."

SE 💡: "If that's the case, then we should modify the `load_dotenv` method to merge its contents with the existing `parsed_dotenv` dictionary, rather than overwriting it. This will preserve any variables set via `set_vars`."

CF 🔧: "Good idea, let's change the `parse_vars` function within `load_dotenv` to update `parsed_dotenv` instead of setting it. Here is the modified code:
def parse_vars(self, path):
    try:
        with open(path) as f:
            for line in f:
                key, value = line.strip().split("=", 1)
                if key not in self.config.parsed_dotenv:  # check if key is not already in the dictionary
                    self.config.parsed_dotenv[key] = value
    except IOError:
        print(f"Warning: Unable to open .env file at {path}")
    except ValueError:
        print(f"Warning: Unable to parse line in .env file: {line}")
"In this way, we only add a variable from the .env file if it's not already in `parsed_dotenv`. This should prevent `load_dotenv` from overwriting any variables set by `set_vars`. Let's re-run the tests."
```

Cependant, le processus n'est pas parfait. Les limites humaines telles que le copier-coller et les délais de génération des invites/résultats peuvent créer des goulets d'étranglement. De plus, le GPT n'est pas toujours précis, changeant parfois de format ou n'offrant que des résultats partiels. Mais avec de la pratique et les bonnes stratégies, vous pouvez guider le GPT pour qu'il génère un code utile et précis.

Éviter les hallucinations et obtenir des résultats utiles
---------------------------------------------------------

Les hallucinations, ou les cas où GPT génère des informations non pertinentes, biaisées ou incorrectes, peuvent être frustrantes. Cependant, plus vous travaillez avec GPT, plus vous parvenez à l'orienter vers les résultats souhaités. Une façon de minimiser ces hallucinations est de fournir un contexte à GPT en copiant et en collant la documentation pertinente et les échantillons de code.

Construire un agent Langchain personnalisé avec des tests exemple :

```js
We have this builder:
class OpenAIBuilder:
  def __init(self, ...):
    # Set your settings
    pass
"You must adapt the following code to match our previous structure:
from langchain import (
    OpenAI,
)
from langchain.agents import initialize_agent, AgentType
from langchain.agents.agent_toolkits import create_python_agent
from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.tools.python.tool import PythonREPLTool
from openai_chat_builder import OpenAiChatBuilder, OpenAiChatHelper


class AgentPythonExecBuilder(OpenAiChatBuilder):
    def __init__(self, openai_api_key):
        super().__init__()
          self.tools = ["PythonREPLTool"]

    # We override the add_tool method so it only allows PythonREPLTool.
    def add_tool(self, tool):
        if tool == "PythonREPLTool":
            return super().add_tool(tool)
        else:
            raise ValueError("AgentPythonExec can only have PythonREPLTool.")

    def build(self):
        llm = OpenAI(
            temperature=self.temperature,
            max_tokens=self.max_tokens,
            openai_api_key=self.openai_api_key,
            streaming=self.streaming,
        )

        tools = load_tools(self.tools)
        agent = initialize_agent(tools, llm, agent=self.agentType, verbose=self.verbose)

        return OpenAiChatHelper(llm, tools, agent)
```

Construire un agent Langchain tests :

```js
Now let's build a test file that resembles this one:
import unittest

from probable_fiesta.config.builder.config_builder import ConfigBuilder
from src.promptnub_backend.app.langchain.builder.openai_factory import OpenAIFactory
from langchain.llms import OpenAI


class TestOpenAIBuilder(unittest.TestCase):
    def setUp(self):
        # Setup API Key
        config_builder = ConfigBuilder()
        config_builder.dotenv.load_dotenv(".env")

        # Setup ModelBuilder instance
        self.builder = OpenAIFactory()
        self.builder.openai_api_key = config_builder.dotenv.get_var("OPENAI_API_KEY")

    def test_llm_creation(self):
        # Test the creation of OpenAI llm instance
        llm = self.builder.builder.llm
        self.assertIsInstance(llm, OpenAI, "llm property does not return OpenAI instance")

    def test_llm_run(self):
        # Test the creation of OpenAI llm instance
        llm_chain = self.builder.build()
        self.assertIsNotNone(llm_chain)

        # Ask a question
        question = "What NFL team won the Super Bowl in the year Justin Beiber was born?"
        response = llm_chain.run(question)

        # Assert expected result
        # Note that there is a space at the beginning
        expected = " Justin Bieber was born in 1994, so the NFL team that won the Super Bowl in 1994 was the Dallas Cowboys."
        self.assertEquals(str(response), expected)
```

GPT-4 Réponse :

```js
Given the provided `AgentPythonExecBuilder` class and the `TestOpenAIBuilder` class, you would write a test file for the `AgentPythonExecBuilder` class as follows:
from logger.builder.logger_factory import LoggerFactory
from config.builder.config_builder import ConfigBuilder
from langchain.llms import OpenAI
from langchain.tools.python.tool import PythonREPLTool
from your_package_path.builder.agent_python_exec_factory import AgentPythonExecFactory

import unittest

# Test Log
LOG_TEST = LoggerFactory.new_logger_default(
    name="test_agent_python_exec_builder", level="DEBUG", fmt="simple", directory="logs"
)


class TestAgentPythonExecBuilder(unittest.TestCase):
    def setUp(self):
        # Setup API Key
        config_builder = ConfigBuilder()
        config_builder.dotenv.load_dotenv(".env")
        # Setup ModelBuilder instance
        self.builder = AgentPythonExecFactory()
        self.builder.openai_api_key = config_builder.dotenv.get_var("OPENAI_API_KEY")

    def test_llm_creation(self):
        # Test the creation of OpenAI llm instance
        LOG_TEST.info("Test OpenAI llm creation")
        llm = self.builder.builder.llm
        LOG_TEST.debug(llm)
        self.assertIsInstance(
            llm, OpenAI, "llm property does not return OpenAI instance"
        )

    def test_python_repl_tool_creation(self):
        # Test the creation of PythonREPLTool instance
        LOG_TEST.info("Test PythonREPLTool creation")
        self.builder.builder.add_tool("PythonREPLTool")
        tools = self.builder.builder.tools
        LOG_TEST.debug(tools)
        self.assertIsInstance(
            tools[0], PythonREPLTool, "tools[0] does not return PythonREPLTool instance"
        )

    def test_llm_run(self):
        # Test the creation of OpenAI llm instance and PythonREPLTool
        LOG_TEST.info("Test OpenAI llm and PythonREPLTool run sync")
        llm_chain = self.builder.build()
        self.assertIsNotNone(llm_chain)

        # Ask a question
        question = "What is 2 + 2?"
        response = llm_chain.run(question)
        LOG_TEST.info(response)

        # Assert expected result
        expected = "The result of 2 + 2 is 4."
        self.assertEquals(str(response), expected)  

Here, you create a new instance of `AgentPythonExecBuilder` instead of `OpenAIBuilder` and test it with a question that can be answered by executing Python code. 
```

Génération automatisée de code
------------------------------

La véritable puissance des LLM réside toutefois dans la génération automatisée de code. En utilisant des outils tels que [PubNub](https://www.pubnub.com/)Python, LangChain et [Streamlit](https://streamlit.io/)vous pouvez automatiser la majeure partie de votre flux de travail, ce qui vous permet de vous concentrer sur des tâches plus importantes.

Avec quelques abstractions supplémentaires, nous pouvons intégrer notre simple runner LangChain dans notre flux de travail :

```js
class TestOpenAIBuilder(unittest.TestCase):
    def setUp(self):
        self.runner = Runner()

    def test_run(self):
        response = self.runner.run("What is the capital of France?")
        expected = " France is a country in Europe. The capital of France is Paris."
        self.assertEqual(response, expected)
```

La voie vers un développement 100 fois plus rapide
--------------------------------------------------

Imaginez un développeur avec l'ambition d'amplifier ses compétences de codage, aspirant à atteindre un niveau de productivité de 2X, 3X, ou même un niveau stupéfiant de 50X. Le secret de cette ambition réside dans l'application stratégique des LLM. Cet ensemble d'outils agit comme un levier de productivité, permettant à nos développeurs d'innover de nouvelles plateformes et de conduire des flux de travail automatisés comme jamais auparavant. De quelque chose d'aussi simple qu'un résumé de texte à la génération d'un code de production.

Alors que nous nous aventurons plus avant dans la sphère de l'IA et de son rôle dans le développement de logiciels, il est important de se rappeler que la véritable force réside dans la fusion de la créativité humaine et des capacités de l'IA. Une planification réfléchie, l'application intelligente de l'IA et les outils numériques appropriés peuvent nous permettre de nous transformer en une entreprise plus productive. Cette transition consiste à amplifier le potentiel des développeurs humains grâce à l'IA, et non à les remplacer. L'idée de devenir une entreprise 100X, grâce à l'IA, n'est pas un rêve lointain, mais un avenir réalisable que nous pouvons façonner collectivement.

#### Sommaire

[Planifier à l'avanceRôler](#h-0)[avec des expertsDemander](#h-1)[des idées](#h-2) à[GPTIngénierie des](#h-3)[invitesGénération](#h-7)[manuelle](#h-3)[de codeGénération automatique](#h-4)[de codeGérer les](#h-5)[échecs avec éléganceGénérer du](#h-6)[code avec des invitesPlanifier](#h-7)[à l'avance : La base du succèsRassembler](#h-8)[un panel d'](#h-9)[expertsGénération](#h-10)[manuelle](#h-9)[de code & AIAéviter les](#h-10)[hallucinations et obtenir des résultats](#h-11)[utilesGénération](#h-12)[automatisée](#h-11)[de codeLe](#h-12)[chemin vers un développement 100 fois plus rapide](#h-13)

Comment PubNub peut-il vous aider ?
===================================

Cet article a été publié à l'origine sur [PubNub.com](https://www.pubnub.com/blog/developers-guide-to-prompt-engineering/)

Notre plateforme aide les développeurs à construire, livrer et gérer l'interactivité en temps réel pour les applications web, les applications mobiles et les appareils IoT.

La base de notre plateforme est le réseau de messagerie en temps réel le plus grand et le plus évolutif de l'industrie. Avec plus de 15 points de présence dans le monde, 800 millions d'utilisateurs actifs mensuels et une fiabilité de 99,999 %, vous n'aurez jamais à vous soucier des pannes, des limites de concurrence ou des problèmes de latence causés par les pics de trafic.

Découvrez PubNub
----------------

Découvrez le [Live Tour](https://www.pubnub.com/tour/introduction/) pour comprendre les concepts essentiels de chaque application alimentée par PubNub en moins de 5 minutes.

S'installer
-----------

Créez un [compte PubNub](https://admin.pubnub.com/signup/) pour un accès immédiat et gratuit aux clés PubNub.

Commencer
---------

La [documentation PubNub](https://www.pubnub.com/docs) vous permettra de démarrer, quel que soit votre cas d'utilisation ou votre [SDK](https://www.pubnub.com/docs).