0Pricing
LangChain / RAG / Vector DBs · Ders

İstemler, LLM'ler ve Temel Zincirler

İstem mühendisliği sanatında uzmanlaşın, çeşitli LLM sağlayıcılarına bağlanın ve temel görevler için basit sıralı zincirler oluşturun.

İstemler, LLM'ler ve Temel Zincirler, CoddyKit'te ücretsiz bir LangChain / RAG / Vector DBs dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, LangChain / RAG / Vector DBs öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. LangChain / RAG / Vector DBs kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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.

Sıkça Sorulan Sorular

“İstemler, LLM'ler ve Temel Zincirler” dersi ücretsiz mi?

Evet — “İstemler, LLM'ler ve Temel Zincirler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve LangChain / RAG / Vector DBs kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. LangChain / RAG / Vector DBs kursu toplamda 4 dersten oluşur.

“İstemler, LLM'ler ve Temel Zincirler” dersinde ne öğreneceğim?

İstem mühendisliği sanatında uzmanlaşın, çeşitli LLM sağlayıcılarına bağlanın ve temel görevler için basit sıralı zincirler oluşturun. LangChain / RAG / Vector DBs ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

LangChain / RAG / Vector DBs öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te LangChain / RAG / Vector DBs, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“İstemler, LLM'ler ve Temel Zincirler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu LangChain / RAG / Vector DBs dersinde kod yazıp çalıştırabilir miyim?

Evet. Her LangChain / RAG / Vector DBs dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. LangChain Ortamınızı Kurma
  2. İstemler, LLM'ler ve Temel Zincirler
  3. Çıktı Ayrıştırıcıları ve Geri Çağırmalar
  4. LangChain'de Bellek ve Konuşma Bağlamı
← LangChain / RAG / Vector DBs Sayfasına Dön