0Pricing
LangChain / RAG / Vector DBs · Pelajaran

Prompt, LLM, dan Rantai Dasar

Kuasai seni rekayasa prompt, hubungkan ke berbagai penyedia LLM, dan buat rantai berurutan sederhana untuk tugas dasar.

Prompt, LLM, dan Rantai Dasar adalah pelajaran LangChain / RAG / Vector DBs gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar LangChain / RAG / Vector DBs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus LangChain / RAG / Vector DBs mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Prompt, LLM, dan Rantai Dasar” gratis?

Ya — teks lengkap “Prompt, LLM, dan Rantai Dasar” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus LangChain / RAG / Vector DBs, upgrade ke CoddyKit PRO. Kursus LangChain / RAG / Vector DBs mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Prompt, LLM, dan Rantai Dasar”?

Kuasai seni rekayasa prompt, hubungkan ke berbagai penyedia LLM, dan buat rantai berurutan sederhana untuk tugas dasar. Kamu berlatih LangChain / RAG / Vector DBs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai LangChain / RAG / Vector DBs?

Tidak diperlukan pengalaman sebelumnya. LangChain / RAG / Vector DBs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Prompt, LLM, dan Rantai Dasar” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran LangChain / RAG / Vector DBs ini?

Ya. Setiap pelajaran LangChain / RAG / Vector DBs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Menyiapkan Lingkungan LangChain
  2. Prompt, LLM, dan Rantai Dasar
  3. Pengurai Keluaran dan Callback
  4. Memori dan Konteks Percakapan dalam LangChain
← Kembali ke LangChain / RAG / Vector DBs