0Pricing
LangChain / RAG / Vector DBs · Leçon

Invites, LLM et chaînes élémentaires

Maîtrisez l’art de l’ingénierie des invites, connectez-vous à différents fournisseurs de LLM et créez des chaînes séquentielles simples pour les tâches de base.

Invites, LLM et chaînes élémentaires est une leçon LangChain / RAG / Vector DBs gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage LangChain / RAG / Vector DBs, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours LangChain / RAG / Vector DBs comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Prompts, LLMs, & Chains

Welcome to this lesson! We'll explore the fundamental building blocks of LangChain: Prompts, Large Language Models (LLMs), and Chains.

These three components are at the heart of almost every application you'll build with LangChain, enabling powerful interactions with AI.

The Art of Prompt Engineering

A prompt is the input text you give to an LLM to guide its response. Crafting effective prompts is known as prompt engineering.

Good prompts are clear, concise, and provide enough context for the LLM to generate the desired output. They are crucial for getting useful results.

Dynamic Prompts with Templates

Instead of hardcoding prompts, LangChain uses PromptTemplate to create dynamic prompts. This allows you to insert variables into your prompt text.

Here's a simple example of how to define a template and format it:

from langchain_core.prompts import PromptTemplate

def main():
    template = "What is a good name for a company that makes {product}?"
    prompt = PromptTemplate.from_template(template)

    # Format the prompt with a specific product
    formatted_prompt = prompt.format(product="colorful socks")
    print(formatted_prompt)

if __name__ == "__main__":
    main()

Connecting to LLMs

LangChain provides a unified interface to interact with various Large Language Models (LLMs), such as OpenAI's GPT series or Google's Gemini.

You typically need an API key from your chosen provider. LangChain abstracts away the specifics, letting you swap models easily.

Making Your First LLM Call

Let's see how to connect to an LLM and make a simple call. We'll use ChatOpenAI as a common example, but the pattern is similar for others.

Remember to set your API key as an environment variable (OPENAI_API_KEY).

import os
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

def main():
    # Make sure your OPENAI_API_KEY is set as an environment variable
    # os.environ["OPENAI_API_KEY"] = "your_api_key_here"

    if "OPENAI_API_KEY" not in os.environ:
        print("Please set the OPENAI_API_KEY environment variable.")
        return

    llm = ChatOpenAI(temperature=0.7)
    
    # Invoke the LLM with a simple message
    response = llm.invoke([HumanMessage(content="Tell me a short, funny story.")])
    print(response.content)

if __name__ == "__main__":
    main()

What are LangChain Chains?

Chains are a core concept in LangChain. They allow you to combine LLMs with other components, or even other chains, into multi-step workflows.

Instead of making individual LLM calls, chains let you define a sequence of operations, making your applications more structured and powerful.

The Simple LLMChain

The LLMChain is one of the simplest and most fundamental chains. It combines a PromptTemplate and an LLM (or ChatModel) into a single, executable unit.

It takes input variables, formats them into the prompt, sends the prompt to the LLM, and returns the LLM's response.

Building Your First LLMChain

Let's create an LLMChain to generate company names based on a product description. We'll use the prompt template and LLM we discussed.

This shows how easy it is to link a prompt and an LLM together.

import os
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate

def main():
    # Set your API key
    if "OPENAI_API_KEY" not in os.environ:
        print("Please set the OPENAI_API_KEY environment variable.")
        return

    # 1. Define the PromptTemplate
    prompt_template = PromptTemplate.from_template(
        "What is a creative name for a company that makes {product}?"
    )

    # 2. Initialize the LLM
    llm = ChatOpenAI(temperature=0.7)

    # 3. Create the LLMChain
    chain = LLMChain(llm=llm, prompt=prompt_template)

    # 4. Run the chain with an input
    response = chain.invoke({"product": "eco-friendly water bottles"})
    print(response["text"])

if __name__ == "__main__":
    main()

Chaining Multiple Inputs

An LLMChain can handle multiple input variables in its prompt template, making it highly flexible. Just ensure all variables are provided when invoking the chain.

Here's an example with two inputs: product and style.

import os
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate

def main():
    # Set your API key
    if "OPENAI_API_KEY" not in os.environ:
        print("Please set the OPENAI_API_KEY environment variable.")
        return

    # Define a prompt with multiple input variables
    prompt_template = PromptTemplate.from_template(
        "Suggest {num} {style} names for a company that sells {product}."
    )

    llm = ChatOpenAI(temperature=0.8)
    chain = LLMChain(llm=llm, prompt=prompt_template)

    # Invoke the chain with all required inputs
    response = chain.invoke({
        "num": 3,
        "style": "modern",
        "product": "handmade jewelry"
    })
    print(response["text"])

if __name__ == "__main__":
    main()

Quick Check

You've learned about prompts, LLMs, and basic chains. Let's test your understanding of how these pieces fit together in LangChain.

Recap & Next Steps

Great job! In this lesson, you've mastered the fundamentals:

  • Prompt Engineering: How to craft effective inputs for LLMs.
  • LLM Integration: Connecting to and making calls with Large Language Models using LangChain.
  • Basic Chains: Understanding and building your first LLMChain to sequence prompts and LLMs.

These skills are essential for building more complex applications. Next, we'll dive into Output Parsers and Callbacks to further control and monitor your LangChain applications.

Questions Fréquemment Posées

La leçon « Invites, LLM et chaînes élémentaires » est-elle gratuite ?

Oui — le texte complet de « Invites, LLM et chaînes élémentaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours LangChain / RAG / Vector DBs, passe à CoddyKit PRO. Le cours LangChain / RAG / Vector DBs comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Invites, LLM et chaînes élémentaires » ?

Maîtrisez l’art de l’ingénierie des invites, connectez-vous à différents fournisseurs de LLM et créez des chaînes séquentielles simples pour les tâches de base. Tu pratiques LangChain / RAG / Vector DBs avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer LangChain / RAG / Vector DBs ?

Aucune expérience préalable n'est requise. LangChain / RAG / Vector DBs sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Invites, LLM et chaînes élémentaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon LangChain / RAG / Vector DBs ?

Oui. Chaque leçon LangChain / RAG / Vector DBs inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Configuration de votre environnement LangChain
  2. Invites, LLM et chaînes élémentaires
  3. Analyseurs de sorties et fonctions de rappel
  4. Mémoire et contexte conversationnel dans LangChain
← Retour à LangChain / RAG / Vector DBs