LangChain. Часть 4. Использование памяти и хранилища в LangChain: подробное руководство

Код можно найти здесь: GitHub — jamesbmour/blog_tutorials:

В постоянно развивающемся мире диалогового искусственного интеллекта и языковых моделей поддержание контекста и эффективное управление информационными потоками являются важнейшими компонентами создания интеллектуальных приложений. LangChain, мощная платформа, предназначенная для работы с большими языковыми моделями (LLM), предлагает надежные инструменты для управления памятью и сохранения данных, что позволяет создавать контекстно-зависимые системы.

В этом руководстве мы углубимся в нюансы использования памяти и хранилища в LangChain для создания более умных и быстро реагирующих приложений.

1. Работа с памятью в LangChain

Управление памятью в LangChain позволяет приложениям сохранять контекст, делая взаимодействие более последовательным и контекстуально релевантным. Давайте рассмотрим различные типы памяти и варианты их использования.

1.1. Типы памяти

LangChain предоставляет различные типы памяти для решения различных сценариев. Здесь мы сосредоточимся на двух типах ключей:

ConversationBufferMemory

Этот тип памяти идеально подходит для кратковременного удержания контекста, фиксации и воспроизведения недавних взаимодействий в разговоре.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "What's the weather like?"}, {"output": "I'm sorry, I don't have real-time weather information. Is there anything else I can help you with?"})

print(memory.load_memory_variables({}))

Сводка беседыПамять

Для более длительных разговоров отличным выбором станет ConversationSummaryMemory. В нем обобщаются ключевые моменты, сохраняя контекст без излишней детализации.

from langchain.memory import ConversationSummaryMemory
from langchain.llms import Ollama 

llm = Ollama(model='phi3',temperature=0)
memory = ConversationSummaryMemory(llm=llm)
memory.save_context({"input": "Hi, I'm Alice"}, {"output": "Hello Alice, how can I help you today?"})
memory.save_context({"input": "I'm looking for a good Italian restaurant"}, {"output": "Great! I'd be happy to help you find a good Italian restaurant. Do you have any specific preferences or requirements, such as location, price range, or specific dishes you're interested in?"})

print(memory.load_memory_variables({}))

1.2. Выбор правильного типа памяти для вашего случая использования

Выбор подходящего типа памяти зависит от нескольких факторов:

• Продолжительность и сложность: короткие сеансы выигрывают от детального сохранения контекста с помощью ConversationBufferMemory, тогда как долгосрочные взаимодействия могут потребовать обобщения с помощью ConversationSummaryMemory.
• Подробности или обзор: определите, что более ценно для вашего приложения — подробная история взаимодействия или общие сводки.
• Производительность: учитывайте компромисс между размером памяти и скоростью извлечения.

Случаи использования:

• ConversationBufferMemory: идеально подходит для быстрой поддержки клиентов или взаимодействия в стиле часто задаваемых вопросов.
• ConversationSummaryMemory: лучше всего подходит для долгосрочных задач, таких как управление проектами или постоянное взаимодействие с клиентами.

1.3. Интеграция памяти в цепочки и агенты

Память может быть легко интегрирована в цепочки и агенты LangChain для расширения возможностей общения.

from langchain.chains import ConversationChain  
from langchain.memory import ConversationBufferMemory
# llm = OpenAI(temperature=0)
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

conversation.predict(input="Hi, I'm Alice")
conversation.predict(input="What's my name?")

Этот пример иллюстрирует, как ConversationBufferMemory можно использовать для запоминания предыдущих взаимодействий, обеспечивая более естественный диалог.

2. Сохранение и получение данных

Постоянное хранилище обеспечивает сохранение истории и контекста разговоров на протяжении всех сеансов, обеспечивая непрерывность взаимодействия.

2.1. Сохранение истории и состояния разговора

Для базового сохранения вы можете использовать файловое хранилище с JSON:

import json

class PersistentMemory:
    def __init__(self, file_path):
        self.file_path = file_path
        self.load_memory()

    def load_memory(self):
        try:
            with open(self.file_path, 'r') as f:
                self.chat_memory = json.load(f)
        except FileNotFoundError:
            self.chat_memory = {'messages': []}

    def save_memory(self):
        with open(self.file_path, 'w') as f:
            json.dump({'messages': self.chat_memory['messages']}, f)

# Usage
memory = PersistentMemory(file_path='conversation_history.json')
print(memory.chat_memory)

Этот метод позволяет сохранять историю разговоров в простом, удобном для чтения формате.

2.2. Интеграция с базами данных и системами хранения данных

Для более масштабируемого и эффективного хранилища рекомендуется интеграция с такими базами данных, как SQLite:

import sqlite3

class SQLiteMemory:
    def __init__(self, db_path):
        self.db_path = db_path
        self.conn = sqlite3.connect(db_path)
        self.create_table()

    def create_table(self):
        cursor = self.conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS conversations
            (id INTEGER PRIMARY KEY, input TEXT, output TEXT)
        ''')
        self.conn.commit()

    def save_context(self, inputs, outputs):
        cursor = self.conn.cursor()
        cursor.execute('INSERT INTO conversations (input, output) VALUES (?, ?)',
                       (inputs['input'], outputs['output']))
        self.conn.commit()

    def load_memory_variables(self, inputs):
        cursor = self.conn.cursor()
        cursor.execute('SELECT input, output FROM conversations ORDER BY id DESC LIMIT 10')
        rows = cursor.fetchall()
        history = "\\n".join([f"Human: {row[0]}\\nAI: {row[1]}" for row in reversed(rows)])
        return {"history": history }

# Usage
memory = SQLiteMemory('conversation_history.db')

print(memory.load_memory_variables({}))

3 Оптимизация использования памяти и производительности

Чтобы ваше приложение оставалось отзывчивым, рассмотрите следующие стратегии оптимизации:

• Эффективные структуры данных: используйте такие структуры, как deque, для управления буферами фиксированного размера.
• Стратегии кэширования: сократите количество запросов к базе данных за счет реализации кэширования часто используемых данных.
• Сокращение данных: регулярно удаляйте или суммируйте старые данные, чтобы поддерживать управляемый объем памяти.

Вот пример класса памяти с базовым кэшированием:

import time

class CachedSQLiteMemory(SQLiteMemory):
    def __init__(self, db_path, cache_ttl=60):
        super().__init__(db_path)
        self.cache = None
        self.cache_time = 0
        self.cache_ttl = cache_ttl

    def load_memory_variables(self, inputs):
        current_time = time.time()
        if self.cache is None or (current_time - self.cache_time) > self.cache_ttl:
            var = self.cache
            self.cache = super().load_memory_variables(inputs)
            self.cache_time = current_time
            return self.cache

memory = CachedSQLiteMemory('conversation_history.db', cache_ttl=30)

Эта реализация кэширует результаты запросов к базе данных в течение определенного времени, снижая нагрузку на базу данных и повышая производительность приложений, которые часто обращаются к данным в памяти.

Заключение

Эффективное управление памятью — краеугольный камень создания интеллектуальных, контекстно-зависимых диалоговых приложений ИИ. LangChain предоставляет гибкую и мощную платформу для управления памятью, позволяющую разработчикам адаптировать типы памяти к конкретным сценариям использования, внедрять решения постоянного хранения и оптимизировать производительность для крупномасштабных приложений.

Выбирая правильный тип памяти, интегрируя постоянное хранилище и используя передовые методы, такие как настраиваемые классы памяти и стратегии кэширования, вы можете создавать сложные системы искусственного интеллекта, которые поддерживают контекст, улучшают взаимодействие с пользователем и работают эффективно даже в условиях масштаба и сложности. взаимодействий растет.

Имея в своем распоряжении эти инструменты и методы, вы хорошо подготовлены к использованию всего потенциала LangChain в создании адаптивных, интеллектуальных и контекстно-зависимых приложений искусственного интеллекта. Независимо от того, разрабатываете ли вы ботов для поддержки клиентов, виртуальных помощников или сложные диалоговые системы, освоение памяти и хранилища в LangChain станет ключевым фактором вашего успеха.

Если вы хотите поддержать мое письмо или купить мне пива:
https://buymeacoffee.com/bmours