Python'da Görevleri Otomatikleştirmek için LangChain Agent'ları Oluşturma

Kurulum

Her şeye başlamadan önce, eğitimin ortamını kuralım.

Önce yeni bir Conda ortamı oluşturalım:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

LangChain paketlerini ve birkaç gerekli kütüphaneyi yükleyelim:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Yeni oluşturulan Conda ortamını Jupyter’a çekirdek olarak ekleyelim:

$ ipython kernel install --user --name=langchain

API anahtarları gibi gizlileri saklamak için bir .env dosyası oluşturalım:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

OpenAI API anahtarınızı .env dosyasından çekelim:

import os
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv('OPENAI_API_KEY')

Her şeyin doğru çalıştığını GPT-3.5’i (OpenAI’nin varsayılan dil modeli) sorgulayarak test edelim:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Artık başlamaya hazırız.

LangChain Agent’ları Nedir?

Biraz agent çerçevesi üzerine düşünelim. Özellikle, geleneksel zincir (chain) paradigmasından nasıl ayrıldığını ve bir agent’ın bileşenlerinin neler olduğunu ele alacağız. Uygulamaları inşa etmek için neden yeni bir yaklaşım seçmemiz gerektiğini anlamak, kod yazmaya hazırlanırken bize yardımcı olacaktır.

Zincirler vs. Agent’lar

Agent’ların ayırt edici özelliği, ellerindeki araçlar kümesi verildiğinde bir problemi çözmek için en iyi eylem sırasını seçebilme yetenekleridir.

Örneğin, elimizde şunların olduğunu varsayalım:

• Bir hava durumu API’si
• Kıyafet önerileri için ML modeli
• Bisiklet rotaları için Strava API’si
• Kullanıcı tercihleri veritabanı
• Görüntü tanıma modeli
• Dil modeli (metin üretimi)

Geleneksel problem çözme yaklaşımı, listeden seçilen araçların bir zincirini kullanmayı içerirdi:

Zincir 1: Hava durumuna dayalı kıyafet önerici

1. Hava durumu API’sini çağır
2. Hava durumu verisini kıyafet ML modeline ver
3. Kıyafet önerileri üret
4. Sonuçları kullanıcıya sun

Zincir 2: Hava durumuna dayalı bisiklet rotası önerici

1. Hava durumu API’sini çağır
2. Popüler rotalar için Strava API’sini çağır
3. Rotaları hava koşullarına göre filtrele
4. Uygun rotaları kullanıcıya sun

Zincir 3: Kıyafet Fotoğrafı Analizi

1. Kullanıcının kıyafet fotoğrafını al
2. Kıyafet öğelerini belirlemek için bir görüntü tanıma modeli kullan
3. Kullanıcı tercihleri veritabanıyla karşılaştır
4. Metin üretim modeliyle geri bildirim oluştur
5. Analizi kullanıcıya sun

Her zincir, mevcut araçların bir alt kümesini ve önceden belirlenmiş bir adım dizisini kullanarak belirli bir problemi çözer. Tanımlı kapsamlarının ötesine uyum sağlayamazlar. Ayrıca, zaman ve kaynak açısından verimsiz olan üç ayrı geliştirme kolu gerektirirler.

Şimdi, tüm bu araçlara erişimi olan bir agentik sistemi hayal edin. Şunları yapabilir:

1. Kullanıcının sorgusunu veya sorununu anlamak (bir dil modeliyle doğal dil üzerinden)
2. Hangi araçların probleme uygun olduğunu değerlendirmek (akıl yürütme)
3. En uygun araçları kullanarak dinamik bir iş akışı oluşturmak
4. Gerekirse gerçek zamanlı ayarlamalar yaparak iş akışını yürütmek (eyleme geçmek)
5. Sonucu değerlendirmek ve geçmiş etkileşimlerden öğrenmek

Örneğin, bir kullanıcı “Bugün bisiklet sürüşüm için ne giymeliyim?” diye sorarsa, agent hava durumu API’sini kontrol edebilir, Strava üzerinden uygun bisiklet rotalarını analiz edebilir, kullanıcının geçmiş tercihlerini dikkate alarak uygun kıyafet önerileri sunabilir ve kişiselleştirilmiş bir yanıt üretebilir.

Agent şunları yapabilir:

• Aynı araç setini kullanarak çok çeşitli problemleri ele almak
• Her benzersiz durum için özel iş akışları oluşturmak
• Yaklaşımlarını bağlama ve kullanıcı ihtiyaçlarına göre uyarlamak
• Etkileşimlerden öğrenerek gelecekteki performansını geliştirmek

LangChain’in, tek başlarına yalnızca metin üreten dil modellerini, ellerindeki kaynakları kullanarak uygun eylemi gerçekleştirebilen akıl yürütme motorlarına dönüştürme kapasitesi başlıca kullanım alanlarından biridir. Kısacası, LangChain dış dünyayla etkileşime giren güçlü otonom agent’ların geliştirilmesini sağlar.

Temel bileşenler

Bir LangChain agent’ı; sohbet modelleri, prompt şablonları, harici araçlar ve diğer ilgili yapılardan oluşur. Başarılı agent’lar oluşturmak için her bileşeni gözden geçirip kullanım amaçlarını anlamamız gerekir.

Dil ve sohbet modelleri

Bir LangChain agent’ı oluşturmada birçok hareketli parça vardır. İlk ve en bariz olanı bir dil modelidir.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

OpenAI’nin GPT-3.5 Turbo’su gibi dil modelleri, string alır ve üretir. Genellikle daha eskidirler ve tekil kullanıcı sorularını yanıtlamada en iyi şekilde çalışırlar.

Daha yeni ve güçlü modeller ise genellikle sohbet modelleridir; bunlar girdi olarak bir mesaj dizisini alır ve çıktı olarak sohbet mesajları döndürür (düz metin yerine):

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Başka bir deyişle, sohbet modelleri doğal dilde konuşmalar yapmamıza izin verir. Yukarıdaki örnekte, bir sistem mesajını bir kullanıcı sorgusunun takip ettiği şekilde GPT-4o-mini’yi başlatıyoruz. SystemMessage ve HumanMessage sınıflarının kullanımına dikkat edin.

output bir mesaj nesnesidir; bu, sohbet modellerinin beklenen davranışıdır:

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Buna ek olarak, nokta gösterimiyle erişilebilen başka yararlı metadata da döndürürler:

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

Çoğu agent, güncel bilgi tabanı ve sohbet yetenekleri nedeniyle sohbet modellerini kullanır. Ancak, bellek gereksinimi olmayan basit agent’lar için GPT-3.5 gibi dil modelleri de yeterli olacaktır.

Prompt şablonları

Dil veya sohbet modellerini sorgulamanın en verimli yolu prompt şablonları kullanmaktır. Sorgularınızı tutarlı bir biçimde yapılandırmanıza ve değişkenleri dinamik olarak eklemenize olanak tanıyarak modelle etkileşimlerinizi daha esnek ve yeniden kullanılabilir kılarlar.

LangChain’de birçok prompt şablonu türü vardır; en temel olanı PromptTemplate sınıfıdır. Düz metin (language) modelleriyle kullanılabilir:

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

Sınıf, süslü parantez gösterimiyle değiştirmek istediğiniz değişkenler için yer tutucular içeren bir string oluşturmanızı ister. Ardından bu şablon metnini, değişken adlarıyla birlikte PromptTemplate sınıfına geçirerek prompt’unuzu oluşturursunuz.

Değişkenler için değerlerle .invoke() çağrısı yapmak, prompt’unuzun modele nasıl iletileceğini gösterir.

Bu prompt şablonunu bir dil modeline geçirmek için pipe operatörüyle zincirlememiz gerekir:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

Pipe operatörü (|) LangChain Expression Language (LCEL)’in bir parçasıdır ve birden çok LangChain bileşenini ve aracını zincirlemek için tasarlanmıştır.

type(chain)

langchain_core.runnables.base.RunnableSequence

LangChain nesnelerinde pipe operatörünü kullandığınızda, RunnableSequence sınıfının bir örneğini oluşturursunuz. Çalıştırılabilir bir dizi, prompt şablonları ve dil/sohbet modelleri gibi .invoke() metodunu destekleyen nesnelerin bir zincirini temsil eder.

Şimdi, sohbet modelleri için başka bir prompt şablonu sınıfına bakalım:

from langchain_core.prompts import ChatPromptTemplate

Sohbet modellerinin girdi olarak bir mesaj dizisi istediğini belirtmiştik. İlk girdi genellikle sohbet modeline nasıl davranacağını söyleyen bir sistem prompt’udur. Dolayısıyla ChatPromptTemplate sınıfını kullanarak farklı kişiliklere sahip sohbet modellerini kolayca oluşturabiliriz:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

Sınıf, girdi olarak role dayalı mesajlardan oluşan bir liste ister. Listedeki her üye, gerekli yerlerde tanımlanmış değişken yer tutucularıyla bir (rol, mesaj) ikilisi olmalıdır.

Hazır olduğunda, aynı pipe operatörünü kullanarak farklı davranışlara sahip sohbet modelleri oluşturabiliriz:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Araçlar

Önceki bir bölümde, agent’ların, kaputun altında akıl yürütme motorları olarak LLM’lerle, belirli bir problemi çözmek için ellerindeki araçların bir kombinasyonunu seçebildiğini belirtmiştik.

LangChain, agent’ların dünyanın geri kalanıyla etkileşime geçmesine olanak tanımak için onlarca popüler API ve hizmetle entegrasyon sunar. Çoğu langchain_community paketinde, bazıları ise langchain_core içinde yer alır.

Örneğin, farklı konularda makale özetleri almak için ArXiv aracını şöyle kullanabilirsiniz:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Araçları sınıf adlarıyla içe aktarmak yerine yüklemenin alternatif bir yolu daha vardır:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Yukarıda, load_tools() fonksiyonunu kullanarak hem arXiv’i hem de Dall-E görsel üretim aracını aynı anda yüklüyoruz. Bu fonksiyonla yüklenen araçların kullanım söz dizimi aynıdır:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

load_tools fonksiyonu, araç sınıflarının string adlarını bilmenizi gerektirir; örneğin ArxivQueryRun ile 'arxiv' örneğinde olduğu gibi. Herhangi bir aracın string adını hızlıca kontrol etmek için get_all_tool_names fonksiyonunu çalıştırabilirsiniz:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

load_tools()’un yalnızca bir kısayol fonksiyonu olduğunu unutmayın. Agent’lar kurarken, belirli davranışlarına göre yapılandırmanıza olanak tanıdığı için araçları sınıf kurucularıyla yüklemeniz önerilir.

LangChain Agent’ları Nasıl Kurulur: Adım Adım İş Akışı

Son olarak, bu bölümde önceki bölümlerde edindiğimiz bilgileri kullanarak LangChain agent’larını adım adım nasıl oluşturacağımızı göreceğiz.

Gelecek örneklerde, herhangi bir konuyu üç ortamda açıklayabilen bir agent oluşturacağız: metin, görsel veya video. Daha spesifik olarak, sorulan soruya göre agent konuyu hangi formatta açıklayacağına karar verecek.

Hadi başlayalım. Makalenin başında ele alınan ortam kurulumuna göz atmayı unutmayın. 

1. Araçların tanımlanması

Ortamımızı yapılandırdıktan sonraki ilk adım, agent’ımıza vereceğimiz araçları tanımlamaktır. İçe aktaralım:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Beş sınıf içe aktarıyoruz:

• WikipediaAPIWrapper: Wikipedia API’sine nasıl erişileceğini yapılandırmak için
• WikipediaQueryRun: Wikipedia sayfa özetleri üretmek için
• YouTubeSearchTool: Konular hakkında YouTube videoları aramak için
• DallEAPIWrapper: OpenAI’nin DallE uç noktasına erişimi yapılandırmak için
• OpenAIDALLEImageGenerationTool: Prompt’larla görsel üretmek için

Kullanıcı agent’ımıza bir sorgu gönderdiğinde, konuyu metin formatında bir Wikipedia makalesiyle mi açıklayacağına, görsel anlayış için Dall-E ile bir resim mi oluşturacağına, yoksa daha derin kavrayış için YouTube videoları mı önereceğine karar verecek.

Wikipedia aracıyla başlayarak onları başlatalım:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

DallE görsel üretici:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

YouTube arama aracı:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Araç açıklamalarına özellikle özen gösterin. Agent, hangi aracı kullanacağına sizin verdiğiniz açıklamaya göre karar verecektir. 

Şimdi araçları bir listeye koyacağız:

tools = [wikipedia, dalle, youtube]

Bir agent oluşturmadan da bu araç setini bir sohbet modeline bağlayabiliriz:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Modeli basit bir mesajla çağıralım:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

Çıktı, bir yanıt üretilirken bağlı araçların hiçbirinin kullanılmadığını gösteriyor. Şimdi, modeli eğitim verisinin ötesine bakmaya zorlayacak daha spesifik bir soru soralım:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Metin çıktısı olmadığını, ancak OpenAI’nin DallE’sinin belirtildiğini görüyoruz. Araç henüz çağrılmadı; model yalnızca onu kullanmamızı öneriyor. Onu gerçekten çağırmak — yani eyleme geçmek — için bir agent oluşturmamız gerekir.

2. Basit bir agent oluşturma

Modeli ve araçları tanımladıktan sonra agent’ı oluştururuz. LangChain, langgraph paketinden yüksek seviyeli create_react_agent() arayüzünü sağlayarak ReAct (reason and act) agent’larını hızla oluşturmayı mümkün kılar:

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Agent’ı bir sohbet modeli ve araç listesiyle başlatırken, modele genel olarak nasıl davranacağını söylemek için bir sistem prompt’u da geçiriyoruz. Artık sorgu kabul etmeye hazır:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Muhtemel bir yanıt aldık; araç çağrısı olmadan basit bir metin yanıtı. Şimdi daha nokta atışı bir şey soralım:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Bu kez dört mesaj var. Mesaj sınıf adlarını ve içeriklerini görelim:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

İşte bu! Üçüncü mesaj bir araç çağrısından geliyor; fotosentezle ilgili bir Wikipedia sayfasının özeti. Son mesaj ise yanıtını oluştururken araç çağrısının içeriğini kullanan sohbet modelinden geliyor.

Attığımız son adımları modülerleştirmek için hızlıca bir fonksiyon yazalım:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Sistem prompt’unu iyileştirme

Şimdi, agent’ın nasıl davranması gerektiğine dair ayrıntılı talimatlarla sistem prompt’umuzu güncelleyelim:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Agent’ımızı yeni sistem prompt’u ile yeniden oluşturalım:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Harika, mesajımız (oldukça yönlendiriciydi :) doğrultusunda agent işe en uygun aracı seçti. İşte oluşturulan görsel:

4. Agent’lara bellek ekleme

Şu anda agent’ımız durum bilgisiz; yani önceki etkileşimleri hatırlamıyor:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

Agent’lara sohbet mesaj geçmişi eklemenin en kolay yolu langgraph’ın SqliteSaver sınıfını kullanmaktır:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

SqliteSaver sınıfının .from_conn_string() metodunu kullanarak belleği başlatıyoruz; bu, bir veritabanı dosyası oluşturur. Ardından memory’yi create_react_agent() fonksiyonunun checkpointer parametresine geçiriyoruz.

Şimdi bir yapılandırma sözlüğü oluşturmamız gerekiyor:

config = {'configurable': {'thread_id': 'a1b2c3'}}

Sözlük, bir konuşmayı diğerinden ayırmak için bir thread ID tanımlar ve agent’ımızın .invoke() metoduna geçirilir. Öyleyse execute() fonksiyonumuzu bu davranışı içerecek şekilde güncelleyelim:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Şimdi agent’a önceki sorgularla ilgili bir şey soralım:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Beklendiği gibi, agent önceki mesajları döndürüyor! Artık ChatGPT tarzı bir sohbet arayüzüne ihtiyacımız var ve kendimize özel bir sohbet botumuz hazır demektir.

Gelecek Eğilimler ve Gelişmeler

Makale boyunca, LangChain’in agent’lar açısından nereye gittiğine dair bir fikir edindik. Çok yakın zamana kadar LangChain çoğunlukla AgentExecutor sınıfını kullanıyordu ancak bu, yavaş yavaş langgraph agent’larıyla değiştiriliyor.

Salt LangChain agent’ları başlamak için uygundur, ancak aynı agent’ı LangGraph ile kurmaya kıyasla daha fazla satır kod gerektirirler. Ayrıca, belli bir noktadan sonra AgentExecutor çerçevesi, karmaşık çok araçlı agent’lar kurmak için LangGraph’ın sunduğu esnekliği sağlamaz.

Bu yüzden şimdi dalgayı yakalamak ve doğrudan LangGraph ile başlamak için harika bir zaman.

Ayrıca, üretim düzeyinde LLM uygulamaları geliştirmek için LangChain ekosisteminin çekirdek bir parçası haline gelen LangSmith kullanmaya başlamanızı önemle tavsiye ederiz. İşte bazı temel faydaları:

• Hata ayıklama: LangSmith, agent’ınızın yürütmesine ilişkin ayrıntılı izler sağlar; sorunları belirlemeyi ve düzeltmeyi kolaylaştırır.
• Performans Optimizasyonu: LangSmith ile belirteç kullanımı, gecikme ve diğer performans metriklerini analiz ederek agent’ınızın verimliliğini optimize edebilirsiniz.
• Test ve Değerlendirme: LangSmith, test veri kümeleri oluşturmayı ve yönetmeyi kolaylaştırarak agent’ınızın performansını çeşitli senaryolar boyunca titizlikle değerlendirmenizi sağlar.
• İzleme: Üretim ortamlarında LangSmith, agent’ınızın performansını gerçek zamanlı izleme ve anormallikleri hızla tespit etme olanağı sunar.

LangSmith ile nasıl başlayabileceğiniz şöyle:

1. Ücretsiz bir hesap için kaydolun buradan.
2. Ortam değişkenlerini ayarlayın.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

ve hazırsınız! Dil/sohbet modellerini sorgulamaya başladığınızda, LangSmith her çalıştırma hakkında çeşitli metrikleri kaydetmeye başlar:

Sonuç

Bu yazıda, LangChain agent’larını zincirlerden ayıran özellikleri ve bunları inşa ederken kullanılan önemli yapı taşlarını ele aldık. Önce agent’ların ne olduğu ve karar verme esnekliği ile yetenekleri açısından daha geleneksel zincir yapılardan nasıl ayrıldıkları üzerinde durduk.

Ardından bir agent oluşturmak için bilmeniz gereken temel bileşenlere baktık: sohbet modelleri, araçlar ve prompt şablonları. Son olarak, basit ve gelişmiş agent’ların nasıl kurulacağını gösteren iki örneği çalıştırdık. Doğal dil işleme sürekli gelişiyor ve LangChain agent’ları bu ilerlemenin ön saflarında yer alarak daha akıllı ve esnek bir yapay zeka ailesinin yolunu açıyor.

İşte LangChain bilginizi artırmak için bazı ilgili kaynaklar:

• LangChain ile LLM Uygulamaları Geliştirme Kursu 
• LangChain ile Prompt Engineering’e Giriş 
• LangChain ile LLM Uygulamaları Nasıl Kurulur Eğitimi
• LangChain Araçlarını Kullanarak Tarama Yeteneğine Sahip Bir GPT Modeli Oluşturma
• LangChain vs LlamaIndex: Ayrıntılı Karşılaştırma

Okuduğunuz için teşekkürler!