LangChainGo - руководство с примерами кода

package main
 
import (
    "context"
    "fmt"
    "os"
    "log"
 
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/googleai"
)
 
func main() {
    ctx := context.Background()
    apiKey := os.Getenv("GOOGLE_API_KEY") // Получаем ключ из переменной окружения
 
    llm, err := googleai.New(ctx, googleai.WithAPIKey(apiKey))
    if err != nil {
        log.Fatalf("Ошибка при создании экземпляра LLM: %v", err)
    }
 
    // Теперь можно использовать llm для генерации текста
    prompt := "Объясни концепцию квантовой запутанности простыми словами"
    answer, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
    if err != nil {
        log.Fatalf("Ошибка при генерации текста: %v", err)
    }
 
    fmt.Println(answer)
}

type RateLimitedLLM struct {
    llm        llms.LLM
    limiter    *rate.Limiter
    tokenCount int64
    maxTokens  int64
}
 
func NewRateLimitedLLM(llm llms.LLM, requestsPerMinute float64, maxTokens int64) *RateLimitedLLM {
    return &RateLimitedLLM{
        llm:       llm,
        limiter:   rate.NewLimiter(rate.Limit(requestsPerMinute/60), 1),
        maxTokens: maxTokens,
    }
}
 
func (r *RateLimitedLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
    if err := r.limiter.Wait(ctx); err != nil {
        return "", fmt.Errorf("rate limit wait error: %v", err)
    }
    
    // Приблизительный подсчет токенов (можно использовать более точные алгоритмы)
    estimatedTokens := len(strings.Split(prompt, " ")) * 1.3
    
    if atomic.AddInt64(&r.tokenCount, int64(estimatedTokens)) > r.maxTokens {
        return "", errors.New("token limit exceeded")
    }
    
    return r.llm.Call(ctx, prompt, options...)
}

func LLMMetricsMiddleware(next llms.LLM) llms.LLM {
    return &metricsLLM{
        base:      next,
        startTime: time.Now(),
        metrics:   initMetrics(), // Подключение к системе метрик (Prometheus и т.д.)
    }
}
 
type metricsLLM struct {
    base      llms.LLM
    startTime time.Time
    metrics   *MetricsCollector
}
 
func (m *metricsLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
    start := time.Now()
    promptTokens := approximateTokenCount(prompt)
    
    m.metrics.IncRequestCount(1)
    m.metrics.IncPromptTokens(promptTokens)
    
    result, err := m.base.Call(ctx, prompt, options...)
    
    latency := time.Since(start)
    responseTokens := approximateTokenCount(result)
    
    m.metrics.IncResponseTokens(responseTokens)
    m.metrics.ObserveLatency(latency.Seconds())
    
    // Приблизительная стоимость (зависит от модели)
    m.metrics.AddCost(calculateCost(promptTokens, responseTokens, getModelName(m.base)))
    
    return result, err
}

// Создаем единый пул соединений для всего приложения
var httpClient = &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        100,              // Макс. кол-во простаивающих соединений
        MaxIdleConnsPerHost: 20,               // Макс. кол-во простаивающих соединений на хост
        IdleConnTimeout:     90 * time.Second, // Время ожидания до закрытия простаивающего соединения
    },
    Timeout: 30 * time.Second, // Общий таймаут запроса
}
 
// Используем этот клиент при инициализации LLM
llm, err := openai.New(
    openai.WithAPIKey(apiKey),
    openai.WithHTTPClient(httpClient), // Передаем настроенный клиент
)

# Этап сборки
FROM golang:1.22-alpine AS builder
 
# Установка зависимостей для сборки
RUN apk --no-cache add ca-certificates git
 
WORKDIR /app
 
# Копируем файлы зависимостей и загружаем их
COPY go.mod go.sum ./
RUN go mod download
 
# Копируем исходный код
COPY . .
 
# Компилируем приложение
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags="-w -s" -o main ./cmd/app
 
# Финальный этап
FROM alpine:latest
 
# Необходимые сертификаты для HTTPS запросов
RUN apk --no-cache add ca-certificates
 
WORKDIR /root/
 
# Копируем бинарный файл из этапа сборки
COPY --from=builder /app/main .
 
# Запуск приложения
CMD ["./main"]

package main
 
import (
    "context"
    "fmt"
    "log"
    "os"
 
    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/googleai"
)
 
func main() {
    // Создаем контекст с таймаутом
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    // Получаем API ключ из переменных окружения
    apiKey := os.Getenv("GOOGLE_API_KEY")
    if apiKey == "" {
        log.Fatal("GOOGLE_API_KEY не установлен")
    }
    
    // Инициализируем LLM
    llm, err := googleai.New(ctx, 
        googleai.WithAPIKey(apiKey),
        googleai.WithModel("gemini-pro"), // Указываем конкретную модель
    )
    if err != nil {
        log.Fatalf("Ошибка при создании LLM: %v", err)
    }
    
    // Создаем запрос к модели
    prompt := "Напиши короткое стихотворение о программировании на Go"
    
    // Генерируем ответ
    response, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
    if err != nil {
        log.Fatalf("Ошибка при генерации текста: %v", err)
    }
    
    fmt.Println("Ответ от Gemini:")
    fmt.Println(response)
}

func callWithRetry(ctx context.Context, llm llms.LLM, prompt string) (string, error) {
    var result string
    var lastErr error
    
    backoff := time.Second
    maxRetries := 3
    
    for i := 0; i < maxRetries; i++ {
        result, lastErr = llms.GenerateFromSinglePrompt(ctx, llm, prompt)
        if lastErr == nil {
            return result, nil
        }
        
        // Проверяем тип ошибки - некоторые не имеет смысла ретраить
        if strings.Contains(lastErr.Error(), "content policy violation") {
            return "", lastErr // Не ретраим нарушения политики контента
        }
        
        log.Printf("Попытка %d завершилась с ошибкой: %v. Повтор через %v", i+1, lastErr, backoff)
        time.Sleep(backoff)
        backoff *= 2 // Экспоненциальный backoff
    }
    
    return "", fmt.Errorf("исчерпаны попытки после %d ретраев: %w", maxRetries, lastErr)
}

package main
 
import (
    "context"
    "fmt"
    "log"
    "os"
 
    "github.com/tmc/langchaingo/chains"
    "github.com/tmc/langchaingo/llms/openai"
    "github.com/tmc/langchaingo/prompts"
)
 
func main() {
    ctx := context.Background()
    
    // Инициализируем LLM
    llm, err := openai.New(openai.WithAPIKey(os.Getenv("OPENAI_API_KEY")))
    if err != nil {
        log.Fatalf("Ошибка инициализации OpenAI: %v", err)
    }
    
    // Создаем шаблон промпта
    template := `Ты - эксперт по {{.тема}}. 
    Объясни концепцию {{.концепция}} в контексте {{.тема}} простыми словами.`
    
    promptTemplate, err := prompts.NewPromptTemplate(template, 
        []string{"тема", "концепция"})
    if err != nil {
        log.Fatalf("Ошибка создания шаблона: %v", err)
    }
    
    // Создаем LLMChain
    chain := chains.NewLLMChain(llm, promptTemplate)
    
    // Запускаем цепочку с входными данными
    result, err := chains.Call(ctx, chain, map[string]interface{}{
        "тема":      "программирование на Go",
        "концепция": "горутины",
    })
    if err != nil {
        log.Fatalf("Ошибка выполнения цепочки: %v", err)
    }
    
    fmt.Println(result["text"])
}

func createSentimentAnalysisSequence(ctx context.Context, llm llms.LLM) (chains.Chain, error) {
    // Шаблон для извлечения ключевых моментов
    extractorTemplate := `
    Отзыв клиента: {{.отзыв}}
    
    Выдели 3-5 ключевых моментов из этого отзыва в виде списка.
    `
    extractorPrompt, err := prompts.NewPromptTemplate(extractorTemplate, []string{"отзыв"})
    if err != nil {
        return nil, err
    }
    extractorChain := chains.NewLLMChain(llm, extractorPrompt)
    
    // Шаблон для анализа тональности
    sentimentTemplate := `
    Ключевые моменты отзыва: {{.текст}}
    
    Проанализируй тональность каждого момента (позитивная/негативная/нейтральная) 
    и общую тональность. Ответ дай в формате JSON.
    `
    sentimentPrompt, err := prompts.NewPromptTemplate(sentimentTemplate, []string{"текст"})
    if err != nil {
        return nil, err
    }
    sentimentChain := chains.NewLLMChain(llm, sentimentPrompt)
    
    // Соединяем цепочки: extractorChain -> sentimentChain
    sequentialChain := chains.NewSequentialChain(
        []chains.Chain{extractorChain, sentimentChain},
        []string{"отзыв"}, // входные ключи
        []string{"текст"}, // выходные ключи
    )
    
    return sequentialChain, nil
}

template := `{{.системная_инструкция}}
 
КОНТЕКСТ:
{{.контекст}}
 
ВОПРОС:
{{.вопрос}}
 
ИНСТРУКЦИИ:
1. Используй только информацию из контекста
2. Если ответ не содержится в контексте, скажи "Не могу ответить на основе предоставленной информации"
3. Отвечай кратко и по существу
 
ОТВЕТ:`

template := `Решай задачу шаг за шагом:
 
ЗАДАЧА: {{.задача}}
 
Размышление:
1) Сначала я определю, какие данные даны и что нужно найти.
2) Затем я выберу подходящий метод решения.
3) Применю метод и проведу вычисления.
4) Проверю результат и сформулирую ответ.
 
РЕШЕНИЕ:`

func truncateContextToFit(context string, question string, maxTokens int) string {
    // Примерная оценка токенов (в реальности используйте токенайзер)
    questionTokens := len(strings.Split(question, " ")) * 1.3
    
    // Оставляем запас для ответа (примерно 30% от максимума)
    availableTokens := float64(maxTokens) * 0.7 - questionTokens
    
    if availableTokens <= 0 {
        return "" // Вопрос слишком длинный
    }
    
    contextWords := strings.Split(context, " ")
    estimatedContextTokens := float64(len(contextWords)) * 1.3
    
    if estimatedContextTokens <= availableTokens {
        return context // Контекст помещается целиком
    }
    
    // Усекаем контекст, чтобы он поместился
    ratio := availableTokens / estimatedContextTokens
    newLength := int(float64(len(contextWords)) * ratio)
    
    return strings.Join(contextWords[:newLength], " ") + "..."
}

func sanitizeUserInput(input string) string {
    // 1. Удаляем потенциально опасные последовательности
    input = dangerousSequencesRegex.ReplaceAllString(input, "")
    
    // 2. Экранируем специальные символы в шаблоне
    input = strings.ReplaceAll(input, "{{", "{ {")
    input = strings.ReplaceAll(input, "}}", "} }")
    
    // 3. Ограничиваем длину
    if len(input) > 500 {
        input = input[:500] + "..."
    }
    
    return input
}

type CachedLLM struct {
    baseLLM  llms.LLM
    cache    map[string]string
    cacheMux sync.RWMutex
}
 
func NewCachedLLM(baseLLM llms.LLM) *CachedLLM {
    return &CachedLLM{
        baseLLM: baseLLM,
        cache:   make(map[string]string),
    }
}
 
func (c *CachedLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
    // Генерируем ключ кеша
    cacheKey := prompt
    for _, opt := range options {
        // Упрощенный подход; в реальности нужно учитывать все параметры
        cacheKey += fmt.Sprintf("%v", opt)
    }
    
    // Проверяем кеш
    c.cacheMux.RLock()
    cachedResult, found := c.cache[cacheKey]
    c.cacheMux.RUnlock()
    
    if found {
        return cachedResult, nil
    }
    
    // Если не нашли в кеше, делаем реальный запрос
    result, err := c.baseLLM.Call(ctx, prompt, options...)
    if err != nil {
        return "", err
    }
    
    // Сохраняем в кеш
    c.cacheMux.Lock()
    c.cache[cacheKey] = result
    c.cacheMux.Unlock()
    
    return result, nil
}

type ChainFactory struct {
    llm       llms.LLM
    templates map[string]string
}
 
func NewChainFactory(llm llms.LLM) *ChainFactory {
    return &ChainFactory{
        llm: llm,
        templates: map[string]string{
            "summarization": "Сумуммаризуй следующий текст в {{.paragraphs}} абзацев: {{.text}}",
            "translation":   "Переведи текст с {{.from_lang}} на {{.to_lang}}: {{.text}}",
            "qa":            "Контекст: {{.context}}\nВопрос: {{.question}}\nОтвет:",
        },
    }
}
 
func (cf *ChainFactory) CreateChain(chainType string) (chains.Chain, error) {
    templateStr, exists := cf.templates[chainType]
    if !exists {
        return nil, fmt.Errorf("неизвестный тип цепочки: %s", chainType)
    }
    
    promptTemplate, err := prompts.NewPromptTemplate(templateStr, nil) // Переменные определяем динамически
    if err != nil {
        return nil, err
    }
    
    return chains.NewLLMChain(cf.llm, promptTemplate), nil
}

type ModelSelector interface {
    SelectModel(task string, input map[string]interface{}) (llms.LLM, error)
}
 
type CostEffectiveSelector struct {
    cheapModel  llms.LLM // например, gpt-3.5-turbo
    expensiveModel llms.LLM // например, gpt-4
    complexityThreshold int
}
 
func (s *CostEffectiveSelector) SelectModel(task string, input map[string]interface{}) (llms.LLM, error) {
    // Для задач перевода и простых запросов используем дешевую модель
    if task == "translation" {
        return s.cheapModel, nil
    }
    
    // Для сложных задач или длинных контекстов используем дорогую модель
    if task == "reasoning" || task == "analysis" {
        return s.expensiveModel, nil
    }
    
    // Оцениваем сложность по длине входного текста
    if text, ok := input["text"].(string); ok {
        if len(text) > s.complexityThreshold {
            return s.expensiveModel, nil
        }
    }
    
    // По умолчанию используем дешевую модель
    return s.cheapModel, nil
}

type ChainDecorator struct {
baseChain chains.Chain
preProcess  func(map[string]interface{}) map[string]interface{}
postProcess func(map[string]interface{}) map[string]interface{}
}
 
func NewChainDecorator(
baseChain chains.Chain, 
preProcess, postProcess func(map[string]interface{}) map[string]interface{},
) *ChainDecorator {
return &ChainDecorator{
    baseChain:   baseChain,
    preProcess:  preProcess,
    postProcess: postProcess,
}
}
 
func (d *ChainDecorator) Call(ctx context.Context, values map[string]interface{}) (map[string]interface{}, error) {
// Предобработка входных данных
if d.preProcess != nil {
    values = d.preProcess(values)
}
 
// Вызов базовой цепочки
result, err := chains.Call(ctx, d.baseChain, values)
if err != nil {
    return nil, err
}
 
// Постобработка результатов
if d.postProcess != nil {
    result = d.postProcess(result)
}
 
return result, nil
}

type ModelRouter struct {
models map[string]llms.LLM
complexityEvaluator func(prompt string) int // 0-100 шкала сложности
}
 
func (mr *ModelRouter) RoutePrompt(ctx context.Context, prompt string) (string, error) {
complexity := mr.complexityEvaluator(prompt)
 
var selectedModel llms.LLM
switch {
case complexity < 30:
    selectedModel = mr.models["fast"] // Легкая модель для простых запросов
case complexity < 70:
    selectedModel = mr.models["balanced"] // Сбалансированная модель
default:
    selectedModel = mr.models["powerful"] // Мощная модель для сложных запросов
}
 
return llms.GenerateFromSinglePrompt(ctx, selectedModel, prompt)
}

func evaluateComplexity(prompt string) int {
words := strings.Fields(prompt)
wordCount := len(words)
 
// Базовая сложность на основе длины
lengthScore := min(wordCount/10, 40)
 
// Сложность на основе "сложных" слов и фраз
complexTerms := []string{"объясни", "анализируй", "сравни", "оцени", "докажи", "опровергни"}
complexScore := 0
for _, term := range complexTerms {
    if strings.Contains(strings.ToLower(prompt), term) {
        complexScore += 10
    }
}
 
// Сложность на основе вопросительных конструкций
questionScore := 0
if strings.Count(prompt, "?") > 0 {
    questionScore = 10
}
if strings.Count(prompt, "почему") > 0 || strings.Count(prompt, "как") > 0 {
    questionScore += 10
}
 
return min(lengthScore + complexScore + questionScore, 100)
}

func createDocumentProcessingChain(ctx context.Context, llm llms.LLM) (chains.Chain, error) {
// Цепочка для извлечения метаданных из документа
metadataPrompt := `Извлеки следующие метаданные из документа:
1. Заголовок
2. Автор(ы)
3. Дата создания или публикации
4. Ключевые слова (5-7)
 
Документ: {{.document}}
 
Ответ в формате JSON:`
 
metadataTemplate, _ := prompts.NewPromptTemplate(metadataPrompt, []string{"document"})
metadataChain := chains.NewLLMChain(llm, metadataTemplate)
 
// Цепочка для создания краткого содержания
summaryPrompt := `Создай краткое содержание документа (максимум 3 абзаца):
 
Документ: {{.document}}
 
Краткое содержание:`
 
summaryTemplate, _ := prompts.NewPromptTemplate(summaryPrompt, []string{"document"})
summaryChain := chains.NewLLMChain(llm, summaryTemplate)
 
// Цепочка для извлечения ключевых идей
keyPointsPrompt := `Выдели 5-7 ключевых идей или выводов из документа:
 
Документ: {{.document}}
 
Ключевые идеи:`
 
keyPointsTemplate, _ := prompts.NewPromptTemplate(keyPointsPrompt, []string{"document"})
keyPointsChain := chains.NewLLMChain(llm, keyPointsTemplate)
 
// Объединяем в параллельную цепочку, которая запускает все три подцепочки одновременно
parallelChain := chains.NewMultiRouteChain(
    map[string]chains.Chain{
        "metadata":  metadataChain,
        "summary":   summaryChain,
        "keyPoints": keyPointsChain,
    },
    []string{"document"}, // Общий входной ключ для всех подцепочек
)
 
return parallelChain, nil
}

type PromptMetrics struct {
responseTime   time.Duration // Время ответа
tokenCount     int           // Количество токенов
errorRate      float64       // Частота ошибок
confidenceScore float64      // Оценка уверенности модели (0-1)
}
 
func evaluatePrompt(ctx context.Context, llm llms.LLM, promptTemplate *prompts.PromptTemplate, testCases []map[string]interface{}) PromptMetrics {
var metrics PromptMetrics
totalTests := len(testCases)
errors := 0
 
for _, testCase := range testCases {
    startTime := time.Now()
    
    // Формируем промпт из шаблона
    formattedPrompt, err := promptTemplate.Format(testCase)
    if err != nil {
        errors++
        continue
    }
    
    // Подсчитываем токены
    tokens := approximateTokenCount(formattedPrompt)
    metrics.tokenCount += tokens
    
    // Отправляем запрос к LLM
    response, err := llms.GenerateFromSinglePrompt(ctx, llm, formattedPrompt)
    responseTime := time.Since(startTime)
    
    if err != nil {
        errors++
        continue
    }
    
    // Обновляем метрики
    metrics.responseTime += responseTime
    
    // Оцениваем уверенность (упрощенно)
    confidenceScore := evaluateConfidence(response)
    metrics.confidenceScore += confidenceScore
}
 
// Вычисляем средние значения
if totalTests > 0 {
    metrics.responseTime /= time.Duration(totalTests)
    metrics.tokenCount /= totalTests
    metrics.errorRate = float64(errors) / float64(totalTests)
    metrics.confidenceScore /= float64(totalTests)
}
 
return metrics
}
 
func evaluateConfidence(response string) float64 {
// Упрощенная эвристика для оценки уверенности модели
// Наличие фраз неуверенности снижает оценку
uncertaintyPhrases := []string{
    "не уверен", "возможно", "может быть", "предположительно",
    "сложно сказать", "недостаточно информации",
}
 
score := 1.0
for _, phrase := range uncertaintyPhrases {
    if strings.Contains(strings.ToLower(response), phrase) {
        score -= 0.1 // Снижаем оценку за каждую фразу неуверенности
        if score < 0 {
            score = 0
        }
    }
}
 
return score
}

package main
 
import (
    "context"
    "log"
    "os"
 
    "github.com/tmc/langchaingo/embeddings"
    "github.com/tmc/langchaingo/embeddings/openai"
    "github.com/tmc/langchaingo/vectorstores/pinecone"
)
 
func main() {
    ctx := context.Background()
    
    // Инициализация модели эмбеддингов
    embedder, err := openai.NewEmbedder(openai.WithAPIKey(os.Getenv("OPENAI_API_KEY")))
    if err != nil {
        log.Fatalf("Ошибка создания embedder: %v", err)
    }
    
    // Подключение к Pinecone
    store, err := pinecone.New(
        ctx,
        pinecone.WithAPIKey(os.Getenv("PINECONE_API_KEY")),
        pinecone.WithEnvironment("us-west1-gcp"),
        pinecone.WithIndexName("my-index"),
        pinecone.WithEmbedder(embedder),
    )
    if err != nil {
        log.Fatalf("Ошибка подключения к Pinecone: %v", err)
    }
    
    // Теперь можно использовать store для добавления и поиска документов
}

func addDocumentsWithRetry(ctx context.Context, store *pinecone.Store, docs []schema.Document) error {
    maxRetries := 5
    backoff := 100 * time.Millisecond
    
    for attempt := 0; attempt < maxRetries; attempt++ {
        err := store.AddDocuments(ctx, docs)
        if err == nil {
            return nil
        }
        
        log.Printf("Попытка %d завершилась с ошибкой: %v. Повтор через %v", 
            attempt+1, err, backoff)
        time.Sleep(backoff)
        backoff *= 2 // Экспоненциальный backoff
    }
    
    return fmt.Errorf("не удалось добавить документы после %d попыток", maxRetries)
}

package main
 
import (
    "context"
    "log"
 
    "github.com/tmc/langchaingo/embeddings"
    "github.com/tmc/langchaingo/embeddings/openai"
    "github.com/tmc/langchaingo/vectorstores/chroma"
)
 
func main() {
    ctx := context.Background()
    
    embedder, err := openai.NewEmbedder(openai.WithAPIKey(os.Getenv("OPENAI_API_KEY")))
    if err != nil {
        log.Fatal(err)
    }
    
    // Подключение к ChromaDB
    store, err := chroma.New(
        chroma.WithChromaURL("http://localhost:8000"),
        chroma.WithEmbedder(embedder),
        chroma.WithCollectionName("my_collection"),
    )
    if err != nil {
        log.Fatal(err)
    }
    
    // Теперь можно использовать store для операций с документами
}

func prepareRussianText(text string) string {
    // Удаление стоп-слов и нормализация
    stopWords := []string{"и", "в", "на", "с", "по", "к", "от", "для", "что", "как", "это", "так"}
    words := strings.Fields(strings.ToLower(text))
    
    filteredWords := make([]string, 0, len(words))
    for _, word := range words {
        isStopWord := false
        for _, stopWord := range stopWords {
            if word == stopWord {
                isStopWord = true
                break
            }
        }
        
        if !isStopWord {
            filteredWords = append(filteredWords, word)
        }
    }
    
    return strings.Join(filteredWords, " ")
}

type SearchResult struct {
    Document  schema.Document
    Score     float64
}
 
func hybridSearch(ctx context.Context, vectorStore *pinecone.Store, 
                 textQuery string, limit int) ([]SearchResult, error) {
    // Векторный поиск
    vectorResults, err := vectorStore.SimilaritySearch(ctx, textQuery, limit, nil)
    if err != nil {
        return nil, err
    }
    
    // Полнотекстовый поиск (упрощенная версия)
    keywordResults := keywordSearch(vectorResults, textQuery)
    
    // Объединение результатов с весами
    finalResults := mergeResults(vectorResults, keywordResults, 0.7, 0.3)
    
    return finalResults, nil
}

func incrementalIndexing(ctx context.Context, store *pinecone.Store,
                        newDocs []schema.Document, idField string) error {
    // Получаем ID существующих документов
    existingIDs := make(map[string]bool)
    // ... логика получения существующих ID ...
    
    // Фильтруем только новые документы
    var docsToAdd []schema.Document
    for _, doc := range newDocs {
        docID, ok := doc.Metadata[idField].(string)
        if !ok {
            continue
        }
        
        if !existingIDs[docID] {
            docsToAdd = append(docsToAdd, doc)
        }
    }
    
    // Добавляем только новые документы
    if len(docsToAdd) > 0 {
        return store.AddDocuments(ctx, docsToAdd)
    }
    
    return nil
}

func buildRAGSystem(ctx context.Context) (*RAGSystem, error) {
// Инициализируем LLM
llm, err := openai.New(openai.WithAPIKey(os.Getenv("OPENAI_API_KEY")))
if err != nil {
    return nil, fmt.Errorf("ошибка инициализации LLM: %w", err)
}
 
// Инициализируем эмбеддер
embedder, err := openai.NewEmbedder(openai.WithAPIKey(os.Getenv("OPENAI_API_KEY")))
if err != nil {
    return nil, fmt.Errorf("ошибка инициализации эмбеддера: %w", err)
}
 
// Создаем или подключаемся к векторному хранилищу
store, err := chroma.New(
    chroma.WithEmbedder(embedder),
    chroma.WithCollectionName("my_documents"),
)
if err != nil {
    return nil, fmt.Errorf("ошибка подключения к хранилищу: %w", err)
}
 
// Создаем систему RAG
return &RAGSystem{
    LLM:       llm,
    Embedder:  embedder,
    Store:     store,
    MaxTokens: 8000, // Максимальный размер контекста для LLM
}, nil
}

func (rag *RAGSystem) GenerateResponse(ctx context.Context, query string) (string, error) {
// 1. Поиск релевантных документов с повторами при ошибках
var documents []schema.Document
var retrievalErr error
 
for attempt := 0; attempt < 3; attempt++ {
    documents, retrievalErr = rag.Store.SimilaritySearch(ctx, query, 5, nil)
    if retrievalErr == nil {
        break
    }
    time.Sleep(time.Duration(attempt*500) * time.Millisecond)
}
 
if retrievalErr != nil {
    return "", fmt.Errorf("ошибка поиска документов: %w", retrievalErr)
}
 
// 2. Формируем промпт с контекстом
context := prepareContext(documents, rag.MaxTokens)
prompt := fmt.Sprintf(`На основе следующего контекста ответь на вопрос. 
Если не можешь найти ответ в контексте, так и скажи.
 
Контекст: %s
 
Вопрос: %s
 
Ответ:`, context, query)
 
// 3. Генерация ответа с обработкой ошибок
var response string
var llmErr error
 
for attempt := 0; attempt < 3; attempt++ {
    response, llmErr = llms.GenerateFromSinglePrompt(ctx, rag.LLM, prompt)
    if llmErr == nil {
        break
    }
    time.Sleep(time.Duration(attempt*1000) * time.Millisecond)
}
 
if llmErr != nil {
    return "Извините, не удалось сгенерировать ответ. Пожалуйста, попробуйте позже.", nil
}
 
return response, nil
}

func (rag *RAGSystem) MultilingualRAG(ctx context.Context, query string, queryLang, responseLang string) (string, error) {
// Определяем язык запроса, если не указан явно
if queryLang == "" {
    detectedLang := detectLanguage(query)
    queryLang = detectedLang
}
 
// Переводим запрос на английский для поиска (если нужно)
searchQuery := query
if queryLang != "en" {
    translated, err := translateText(ctx, query, queryLang, "en")
    if err != nil {
        // Если перевод не удался, используем оригинальный запрос
        log.Printf("Ошибка перевода запроса: %v", err)
    } else {
        searchQuery = translated
    }
}
 
// Поиск релевантных документов
documents, err := rag.Store.SimilaritySearch(ctx, searchQuery, 5, nil)
if err != nil {
    return "", err
}
 
// Формируем контекст и генерируем ответ
// ... аналогично предыдущему примеру, но с учетом языка ответа
 
// Если нужно, переводим ответ на язык запроса
if responseLang != "en" && responseLang != "" {
    return translateText(ctx, response, "en", responseLang)
}
 
return response, nil
}

func (rag *RAGSystem) SecureSearch(ctx context.Context, query string, userRoles []string) ([]schema.Document, error) {
// Получаем все потенциально релевантные документы
allDocs, err := rag.Store.SimilaritySearch(ctx, query, 20, nil)
if err != nil {
    return nil, err
}
 
// Фильтруем по правам доступа
var accessibleDocs []schema.Document
for _, doc := range allDocs {
    // Проверяем, имеет ли документ метаданные о требуемых ролях
    if requiredRoles, ok := doc.Metadata["required_roles"].([]string); ok {
        if hasAccess(userRoles, requiredRoles) {
            accessibleDocs = append(accessibleDocs, doc)
        }
    } else {
        // Если у документа нет ограничений, считаем его общедоступным
        accessibleDocs = append(accessibleDocs, doc)
    }
}
 
return accessibleDocs[:min(len(accessibleDocs), 5)], nil
}
 
func hasAccess(userRoles, requiredRoles []string) bool {
for _, required := range requiredRoles {
    for _, userRole := range userRoles {
        if required == userRole {
            return true
        }
    }
}
return false
}

docbot/
├── cmd/
│   └── server/           // Точка входа в приложение
├── internal/
│   ├── config/           // Конфигурация
│   ├── indexer/          // Индексация документации
│   ├── llm/              // Работа с LLM
│   ├── store/            // Векторное хранилище
│   ├── chat/             // Логика чата
│   └── handlers/         // HTTP и WebSocket хендлеры
└── web/                  // Веб-интерфейс

type Indexer struct {
loader     document.Loader
splitter   text.Splitter
embedder   embeddings.Embedder
vectorStore vectorstores.Store
}
 
func NewIndexer(loader document.Loader, embedder embeddings.Embedder, store vectorstores.Store) *Indexer {
return &Indexer{
    loader:     loader,
    splitter:   text.NewRecursiveCharacterTextSplitter(1000, 200),
    embedder:   embedder,
    vectorStore: store,
}
}
 
func (i *Indexer) IndexDirectory(ctx context.Context, dirPath string) error {
// Загружаем документы
docs, err := i.loader.LoadFromDir(dirPath)
if err != nil {
    return fmt.Errorf("ошибка загрузки документов: %w", err)
}
 
// Разбиваем на чанки
chunks := make([]schema.Document, 0)
for _, doc := range docs {
    docChunks, err := i.splitter.SplitDocument(doc)
    if err != nil {
        return fmt.Errorf("ошибка разделения документа: %w", err)
    }
    chunks = append(chunks, docChunks...)
}
 
// Добавляем в векторное хранилище
return i.vectorStore.AddDocuments(ctx, chunks)
}

type ChatBot struct {
vectorStore vectorstores.Store
llm         llms.LLM
sessionMgr  *SessionManager
prompts     map[string]string
}
 
func (c *ChatBot) GenerateAnswer(ctx context.Context, question string, sessionID string) (string, error) {
// Получаем историю диалога
session := c.sessionMgr.GetSession(sessionID)
 
// Поиск релевантных документов
docs, err := c.vectorStore.SimilaritySearch(ctx, question, 5, nil)
if err != nil {
    return "", fmt.Errorf("ошибка поиска: %w", err)
}
 
// Подготовка контекста
context := prepareContext(docs)
 
// Формируем промпт с учетом истории и контекста
prompt := fmt.Sprintf(c.prompts["qa"], 
    formatChatHistory(session.Messages),
    context,
    question)
 
// Генерация ответа
answer, err := llms.GenerateFromSinglePrompt(ctx, c.llm, prompt)
if err != nil {
    return "", fmt.Errorf("ошибка генерации: %w", err)
}
 
// Сохраняем сообщение в историю
session.AddMessage("user", question)
session.AddMessage("assistant", answer)
 
return answer, nil
}

func (h *Handler) handleWebSocket(w http.ResponseWriter, r *http.Request) {
upgrader := websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        return true // В реальном проекте здесь должна быть проверка
    },
}
 
// Устанавливаем WebSocket соединение
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
    log.Printf("Ошибка установки WebSocket: %v", err)
    return
}
defer conn.Close()
 
sessionID := uuid.New().String()
 
for {
    // Читаем сообщение от клиента
    _, message, err := conn.ReadMessage()
    if err != nil {
        break
    }
    
    var request ChatRequest
    if err := json.Unmarshal(message, &request); err != nil {
        sendError(conn, "Неверный формат запроса")
        continue
    }
    
    // Обрабатываем запрос в отдельной горутине
    go func() {
        answer, err := h.chatbot.GenerateAnswer(r.Context(), request.Message, sessionID)
        if err != nil {
            sendError(conn, "Ошибка генерации ответа")
            return
        }
        
        response := ChatResponse{
            Type:    "answer",
            Message: answer,
        }
        
        responseJSON, _ := json.Marshal(response)
        conn.WriteMessage(websocket.TextMessage, responseJSON)
    }()
}
}

type RedisSessionManager struct {
client *redis.Client
ttl    time.Duration
}
 
func NewRedisSessionManager(addr string, password string, ttl time.Duration) *RedisSessionManager {
client := redis.NewClient(&redis.Options{
    Addr:     addr,
    Password: password,
    DB:       0,
})
 
return &RedisSessionManager{
    client: client,
    ttl:    ttl,
}
}
 
func (m *RedisSessionManager) GetSession(id string) (*Session, error) {
data, err := m.client.Get(context.Background(), fmt.Sprintf("session:%s", id)).Result()
if err == redis.Nil {
    // Сессия не найдена, создаем новую
    session := NewSession(id)
    return session, nil
}
if err != nil {
    return nil, err
}
 
var session Session
if err := json.Unmarshal([]byte(data), &session); err != nil {
    return nil, err
}
 
return &session, nil
}