Model Bahasa Besar (LLM) seperti model GPT-4 dan Openai menganut model wajah sangat kuat, tetapi menggunakannya secara efektif dalam aplikasi membutuhkan lebih dari sekadar memanggil API. Lubricole adalah kerangka kerja yang menyederhanakan bekerja dengan LLM, memungkinkan pengembang untuk dengan mudah membuat aplikasi AI canggih.

Dalam artikel ini, kami akan membahas:

1. Apa itu Langchain?
2. Cara menginstal dan mengonfigurasi langchain
3. Penggunaan Dasar: Pergi ke Openai LLLS, LLMS di wajah pelukan, model cepat, rantai
4. Contoh satu chatbot langchain

Apa itu Langchain?

Langchain adalah bingkai sumber terbuka yang dirancang untuk membantu pengembang membuat aplikasi yang ditenagai oleh LLMS. Ini menyediakan alat untuk menyusun interaksi LLM, mengelola memori, mengintegrasikan API, dan membuat alur kerja yang kompleks.

Manfaat Langchain

• Menyederhanakan manajemen prompt dan tanggapan
• Mendukung beberapa pemasok LLM (OpenAi, Streced, Face Anthropic, dll.)
• Memungkinkan untuk memori, pemulihan, dan rantai ganda AI
• Mendukung pembangunan chatbots, agen dan aplikasi yang disediakan oleh AI

Panduan Langkah demi Langkah

Langkah 1: Instalasi

Untuk memulai, instal paket Langchain dan OpenAI API menggunakan PIP, buka terminal Anda dan jalankan perintah berikut:

pip install langchain langchain_openai openai

Konfigurasikan kunci API Anda ke variabel lingkungan:

import os
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

Langkah 2: Penggunaan Langchain Charopenai

Sekarang mari kita gunakan model openai untuk menghasilkan teks.

Contoh Dasar: Hasilkan Jawaban

from langchain_openai import ChatOpenAI

# Initialize the model
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)

# write your prompt
prompt = "What is LangChain ?"

# print the response
print(llm.invoke(prompt))

Penjelasan

• from langchain_openai import ChatOpenAI(). Ini penting ChatOpenAI kelas langchain_openai Paket dan memungkinkan Anda menggunakan model Opnai GPT untuk AI percakapan.
• ChatOpenAI(). Ini menginisialisasi model GPT.
• model ="gpt-3.5-turbo". Karena AI terbuka memiliki beberapa model untuk digunakan, kita harus melewati model yang ingin kita gunakan untuk respons cepat. Namun, secara default, buka AI menggunakan text-davinci-003 model.
• temperaure=0.5. Chatopenai diinisialisasi dengan suhu 0,5. Suhu mengontrol peluang dalam jawabannya:
  • 0,0: Deterministik (selalu mengembalikan output yang sama untuk entri yang sama).
  • 0.7: Respons yang lebih kreatif / acak.
  • 1.0: Tanggapan yang sangat acak dan tidak dapat diprediksi.
  • Dari suhu = 0,5, ini menyeimbangkan kreativitas dan keandalan.
• prompt = "What is LangChain?". Di sini, kami mendefinisikan prompt, yang berasal dari Langchain dan akan dikirim ke model Charopenai untuk perawatan.
• llm.invoke(prompt). Ini mengirimkan prompt ke LLM yang diberikan dan mendapatkan jawabannya.

Langkah 3: Penggunaan model LLM lainnya menggunakan HuggingFacepipeline

from langchain_huggingface import HuggingFacePipeline

# Initialize the model, here are trying to use this model - google/flan-t5-base

llm = HuggingFacePipeline.from_model_id(
    model_id="google/flan-t5-base",
    task="text-generation",
    pipeline_kwargs={"max_new_tokens": 200, "temperature" :0.1},
)

# print the response
print(llm.invoke("What is Deep Learning?"))


# In summary here we learned about using different llm using langchain,
# instead OpenAI we used a model on Huggingface. 
# This helps us to interact with models uploaded by community.

Langkah 4: Rantai petunjuk dengan LLMS

Langchain memungkinkan Anda untuk menghubungkan prompt dan model di saluran.

# Prompts template and chaining using langchain
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-4o",temperature=0.9)

# Prompt Template - let you generate prompts that accepts variable, 
# we can have multiple variables as well
template = "What is the impact on my health, if I eat {food} and drink {drink}?"
prompt = PromptTemplate.from_template(template)

# Here chains comes into picture to go beyond single llm call 
# and involve sequence of llm calls, and chains llms and prompt togetger
# Now we initialize our chain with prompt and llm model reference
chain = prompt | llm

# here we are invok the chain with food parameter as Bread and drink parameter as wine.
print(chain.invoke({"food" : "Bread","drink":"wine"}))

Mengapa Menggunakan Langchain?

• Otomatisasi Proses meminta untuk meminta
• Membantu dalam alur kerja dalam beberapa tahap
• Kode modular Dan scalable

Langkah 5: Bentuk beberapa tugas dalam urutan

Saluran Langchain memungkinkan Anda untuk menggabungkan beberapa saluran, di mana pelepasan rantai pertama dapat digunakan sebagai input rantai kedua.

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model_name="gpt-4o", temperature=0)

#first template and chain
template = "Which is the most {adjectective} building in the world ?"
prompt = PromptTemplate.from_template(template)
chain = prompt | llm | StrOutputParser()

#second template and chain with the first chain
template_second = "Tell me more about the {building}?"
prompt_second = PromptTemplate.from_template(template_second)
chain_second = {"noun" : chain} | prompt_second | llm | StrOutputParser()

#invoking the chains of calls passing the value to chain 1 parameter
print(chain_second.invoke({"adjectective" : "famous"}))

Mengapa menggunakan saluran berurutan?

• Gundukan berbagai rantai menggunakan output rantai sebagai pintu masuk untuk yang berikutnya.
• Bekerja dengan melakukan serangkaian saluran
• Penciptaan aliran proses yang mulus

Langkah 5: Menambahkan memori (contoh chatbot)

Apakah Anda ingin chatbot Anda mengingat percakapan masa lalu? Memori Langchain membantu!

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI

# Initialize model with memory
llm = ChatOpenAI(model="gpt-3.5-turbo")
memory = ConversationBufferMemory()

# Create a conversation chain
conversation = ConversationChain(llm=llm, memory=memory)

# Start chatting!
print(conversation.invoke("Hello! How is weather today ?")["response"])
print(conversation.invoke("Can I go out for biking today ?")["response"])

Mengapa Menggunakan Memori?

• Memungkinkan AI untuk mengingat entri masa lalu
• Buat chatbot yang lebih interaktif
• Mendukung beberapa jenis memori (perangko, ringkasan, vektor, dll.)

Apa langkah selanjutnya?

Di sini kami telah menjelajahi beberapa komponen dasar Langchain. Kemudian kita akan menjelajahi elemen di bawah ini untuk menggunakan kekuatan nyata Langchain:

• Mengeksplorasi Agen Langchain Untuk pengambilan keputusan yang dipimpin oleh AI
• Melaksanakan Generasi Auguratif (RAG) Untuk memulihkan data -waktu nyata