דרישות קדם למדריך זה
Python בסיסי, הבנה של API calls, חשבון OpenAI עם API Key. LangChain v0.2+ (המדריך עודכן לגרסה החדשה).
מה זה LangChain ולמה צריך אותו?
LangChain הוא Framework ב-Python (ו-JavaScript) שמפשט את בניית אפליקציות מבוססות LLM. במקום לכתוב עשרות שורות קוד לכל קריאת API, LangChain מספק אבסטרקציות נוחות לשרשראות, זיכרון, כלים וסוכנים.
link
Chains
שרשראות של קריאות LLM, כלים ולוגיקה
memory
Memory
שמירת היסטוריה שיחה בין קריאות
smart_toy
Agents
סוכנים שמחליטים לבד אילו כלים להשתמש
התקנה והגדרה
# התקנה
pip install langchain langchain-openai langchain-community
# הגדרת API Key
import os
os.environ["OPENAI_API_KEY"] = "sk-..."
# או מ-.env file עם python-dotenv
from dotenv import load_dotenv
load_dotenv()
השרשרת הראשונה: Prompt → LLM → Output
הדרך הפשוטה ביותר להשתמש ב-LangChain היא LCEL (LangChain Expression Language) — pipe syntax אלגנטי:
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
# הגדרת המודל
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
# הגדרת הפרומפט
prompt = ChatPromptTemplate.from_messages([
("system", "אתה עוזר עסקי מקצועי שכותב בעברית."),
("human", "{input}")
])
# בניית השרשרת עם LCEL
chain = prompt | llm | StrOutputParser()
# הרצה
result = chain.invoke({"input": "כתוב 3 רעיונות לקמפיין שיווקי לסטארטאפ B2B"})
print(result)
lightbulb
LCEL Streaming — תגובה בזמן אמת
השתמש ב-.stream() במקום .invoke() לקבלת תגובה token-by-token — מושלם ל-UI שמציג טיפוג מדומה.
for chunk in chain.stream({"input": "..."}):
print(chunk, end="", flush=True)
PromptTemplates מתקדמים
שימוש ב-Prompt Templates מאפשר לך ליצור פרומפטים דינמיים ולעשות בהם reuse בקלות:
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
# Prompt עם היסטוריה שיחה
prompt = ChatPromptTemplate.from_messages([
("system", """אתה {role} מקצועי בתחום {domain}.
ענה תמיד בעברית, בצורה {style}."""),
MessagesPlaceholder("chat_history"),
("human", "{question}"),
])
# שימוש
chain = prompt | llm | StrOutputParser()
result = chain.invoke({
"role": "יועץ שיווקי",
"domain": "SaaS",
"style": "קצרה ותכליתית",
"chat_history": [],
"question": "מה האסטרטגיה הטובה ביותר לרכישת לקוחות ראשונים?"
})
Memory — זיכרון בין שיחות
LangChain מציע מספר סוגי זיכרון. הנפוץ ביותר הוא ConversationBufferMemory:
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain
# שמור 10 הודעות אחרונות בלבד (window)
memory = ConversationBufferWindowMemory(k=10, return_messages=True)
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=False
)
# שיחה מתמשכת
conversation.predict(input="שמי דן ואני מנהל חברת SaaS")
conversation.predict(input="מה שמי?") # זוכר: "שמך דן"
ConversationSummaryMemory — לשיחות ארוכות
כשהשיחה מתארכת, Buffer Memory ממלא את ה-Context Window. Summary Memory פותר את זה:
from langchain.memory import ConversationSummaryBufferMemory
# מסכם שיחות ישנות, שומר עדכניות מלאות
memory = ConversationSummaryBufferMemory(
llm=llm,
max_token_limit=500,
return_messages=True
)
RAG — Retrieval Augmented Generation
RAG מאפשר ל-LLM לענות על שאלות מבסיסי ידע חיצוניים (מסמכים, PDF, אתרים) ללא Fine-tuning. זהו אחד מהשימושים הנפוצים ביותר ב-LangChain.
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
# 1. טעינת מסמכים
loader = PyPDFLoader("company_docs.pdf")
docs = loader.load()
# 2. חיתוך לקטעים
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)
chunks = splitter.split_documents(docs)
# 3. יצירת Embeddings ושמירה ב-Vector Store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
# 4. בניית RAG Chain
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(search_kwargs={"k": 4})
)
# 5. שאילת שאלות על המסמך
answer = qa_chain.invoke("מה מדיניות ההחזרות של החברה?")
print(answer["result"])
lightbulb
Pinecone ב-Production: לפרויקטים בסביבת ייצור, החלף Chroma ב-Pinecone לביצועים גבוהים וסקאלביליות. ראה מדריך Pinecone שלנו.
Agents — סוכנים חכמים
Agent הוא LLM שיכול להחליט בעצמו אילו כלים להשתמש בהם כדי לפתור בעיה. הוא רץ בלולאה עד שמגיע לתשובה.
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.tools import tool
from langchain_community.tools import DuckDuckGoSearchRun
# הגדרת כלי מותאם אישית
@tool
def get_company_data(company_name: str) -> str:
"""מחזיר נתונים פיננסיים של חברה. קבל שם חברה."""
# כאן הייתה קריאה ל-API אמיתי
return f"נתונים עבור {company_name}: הכנסות 5M, צמיחה 40%"
# כלי חיפוש
search = DuckDuckGoSearchRun()
# בניית Agent
tools = [search, get_company_data]
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# הרצת Agent
result = agent_executor.invoke({
"input": "חקור את חברת Wix ותן לי ניתוח SWOT קצר"
})
Output Parsers — פלט מובנה
כשצריך JSON מובנה מה-LLM, השתמש ב-PydanticOutputParser:
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
from typing import List
# הגדרת מבנה הפלט
class MarketingIdea(BaseModel):
title: str = Field(description="כותרת הרעיון")
description: str = Field(description="תיאור קצר")
budget_ils: int = Field(description="תקציב משוער בשקלים")
channels: List[str] = Field(description="ערוצי הפצה")
class CampaignIdeas(BaseModel):
ideas: List[MarketingIdea]
# Parser ו-Chain
parser = PydanticOutputParser(pydantic_object=CampaignIdeas)
prompt = ChatPromptTemplate.from_messages([
("system", "ענה בפורמט הבא:\n{format_instructions}"),
("human", "צור 3 רעיונות לקמפיין עבור: {product}")
]).partial(format_instructions=parser.get_format_instructions())
chain = prompt | llm | parser
# תוצאה: object Python מסודר
result = chain.invoke({"product": "אפליקציית מדיטציה לאנשי עסקים"})
for idea in result.ideas:
print(f"{idea.title}: ₪{idea.budget_ils}")
Best Practices לייצור
🔄 Retry ו-Fallback
השתמש ב-.with_retry() לניסיונות חוזרים ו-.with_fallbacks() למעבר למודל אחר בעת כשל.
💾 Caching
הוסף set_llm_cache(InMemoryCache()) לחסוך בקריאות API חוזרות. לייצור — השתמש ב-Redis Cache.
📊 LangSmith — Observability
חבר LangSmith לניטור כל הקריאות, זמנים, עלויות ושגיאות. הכרחי לייצור רציני.
הצעד הבא: RAG מתקדם עם Pinecone
עכשיו שמבינים את LangChain, הצעד הטבעי הוא לשלב Vector DB לייצור. ראה את המדריכים שלנו.