gollm скачать - скачать исходный код gollm

Gollm - Go Mode Language Model

gollm - это пакет Go, предназначенный для того, чтобы помочь вам построить свои собственные AI Golems. Подобно тому, как мистический голем легенды был воплощен в жизнь священными словами, gollm дает вам возможность вдыхать жизнь в ваши творения ИИ, используя силу крупных языковых моделей (LLM). Этот пакет упрощает и упрощает взаимодействие с различными поставщиками LLM, предлагая унифицированный, гибкий и мощный интерфейс для инженеров и разработчиков ИИ для создания своих собственных цифровых слуг.

Документация

Ключевые функции
Реальные приложения
Установка
Быстрый старт
- Основное использование
Быстрая ссылка
- Создание и конфигурация LLM
- Быстрое создание
- Генерировать ответ
- Цепь мысли
- Быстрое оптимизация
- Сравнение модели
Расширенное использование
- Оперативная инженерия
- Предварительно созданные функции (цепь мышления)
- Работа с примерами
- Быстрые шаблоны
- Структурированный выход (проверка вывода JSON)
- Быстрый оптимизатор
- Сравнение модели
- Удержание памяти
Лучшие практики
Примеры и учебные пособия
Статус проекта
Философия
Внося
Лицензия

Ключевые функции

Unified API для нескольких поставщиков LLM: беспрепятственно взаимодействует с различными поставщиками, включая OpenAI, Anpropic, Groq и Ollama. Легко переключаться между моделями, такими как GPT-4, Claude и Llama-3.1.
Легкий переключение поставщика и модели: настроить предпочтительных поставщиков и модели с простыми опциями.
Гибкие параметры конфигурации: Настройка с использованием переменных среды, на основе кода конфигурации или файлов конфигурации.
Усовершенствованная оперативная техника: ремесло сложные инструкции, чтобы эффективно направлять ответы вашего искусственного интеллекта.
Оптимизатор быстрого приглашения: автоматически уточнить и улучшать ваши подсказки для лучших результатов, при поддержке пользовательских метрик и различных систем рейтинга.
Удержание памяти: поддерживать контекст между несколькими взаимодействиями для более когерентных разговоров.
Структурированный выход и проверка: убедитесь, что выходы являются согласованными и надежными с генерацией и проверкой схемы JSON.
Инструменты сравнения поставщиков: производительность тестирования в разных поставщиках LLM и моделях для одной и той же задачи.
Функции ИИ высокого уровня: Используйте предварительно построенные функции, такие как ChainOfThought для сложных задач.
Устойчивая обработка ошибок и повторения: встроенные механизмы повторения для обработки ограничений скорости API и переходных ошибок.
Расширяемая архитектура: легко расширить поддержку новых поставщиков LLM и функций.

Реальные приложения

gollm может выполнять широкий спектр задач с AI, в том числе:

Рабочие процессы создания контента: генерируйте резюме исследований, идеи статьи и утонченные абзацы.
Сложные задачи рассуждения: используйте функцию ChainOfThought для анализа сложных задач пошаговыми.
Структурированная генерация данных: создать и проверять сложные структуры данных с помощью настраиваемых схем JSON.
Анализ производительности модели: сравните производительность различных моделей для конкретных задач.
Оптимизация быстрого: автоматически улучшать подсказки для различных задач.
Смесь агентов: объедините ответы от нескольких поставщиков LLM.

Установка

go get github.com/teilomillet/gollm

Быстрый старт

Основное использование

 package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/teilomillet/gollm"
)

func main () {
    // Load API key from environment variable
    apiKey := os . Getenv ( "OPENAI_API_KEY" )
    if apiKey == "" {
        log . Fatalf ( "OPENAI_API_KEY environment variable is not set" )
    }

    // Create a new LLM instance with custom configuration
    llm , err := gollm . NewLLM (
        gollm . SetProvider ( "openai" ),
        gollm . SetModel ( "gpt-4o-mini" ),
        gollm . SetAPIKey ( apiKey ),
        gollm . SetMaxTokens ( 200 ),
        gollm . SetMaxRetries ( 3 ),
        gollm . SetRetryDelay ( time . Second * 2 ),
        gollm . SetLogLevel ( gollm . LogLevelInfo ),
    )
    if err != nil {
        log . Fatalf ( "Failed to create LLM: %v" , err )
    }

    ctx := context . Background ()

    // Create a basic prompt
    prompt := gollm . NewPrompt ( "Explain the concept of 'recursion' in programming." )

    // Generate a response
    response , err := llm . Generate ( ctx , prompt )
    if err != nil {
        log . Fatalf ( "Failed to generate text: %v" , err )
    }
    fmt . Printf ( "Response: n %s n " , response )
}

## Quick Reference

Here 's a quick reference guide for the most commonly used functions and options in the `gollm` package :

### LLM Creation and Configuration

`` `go
llm, err := gollm.NewLLM(
    gollm.SetProvider("openai"),
    gollm.SetModel("gpt-4"),
    gollm.SetAPIKey("your-api-key"),
    gollm.SetMaxTokens(100),
    gollm.SetTemperature(0.7),
    gollm.SetMemory(4096),
)

Быстрое создание

 prompt := gollm . NewPrompt ( "Your prompt text here" ,
    gollm . WithContext ( "Additional context" ),
    gollm . WithDirectives ( "Be concise" , "Use examples" ),
    gollm . WithOutput ( "Expected output format" ),
    gollm . WithMaxLength ( 300 ),
)

Генерировать ответ

 response , err := llm . Generate ( ctx , prompt )

Цепь мысли

 response , err := tools . ChainOfThought ( ctx , llm , "Your question here" )

Быстрое оптимизация

 optimizer := optimizer . NewPromptOptimizer ( llm , initialPrompt , taskDescription ,
    optimizer . WithCustomMetrics ( /* custom metrics */ ),
    optimizer . WithRatingSystem ( "numerical" ),
    optimizer . WithThreshold ( 0.8 ),
)
optimizedPrompt , err := optimizer . OptimizePrompt ( ctx )

Сравнение модели

 results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )

Расширенное использование

Пакет gollm предлагает ряд расширенных функций для улучшения ваших приложений для искусственного интеллекта:

Оперативная инженерия

Создайте сложные подсказки с несколькими компонентами:

 prompt := gollm . NewPrompt ( "Explain the concept of recursion in programming." ,
    gollm . WithContext ( "The audience is beginner programmers." ),
    gollm . WithDirectives (
        "Use simple language and avoid jargon." ,
        "Provide a practical example." ,
        "Explain potential pitfalls and how to avoid them." ,
    ),
    gollm . WithOutput ( "Structure your response with sections: Definition, Example, Pitfalls, Best Practices." ),
    gollm . WithMaxLength ( 300 ),
)

response , err := llm . Generate ( ctx , prompt )
if err != nil {
    log . Fatalf ( "Failed to generate explanation: %v" , err )
}

fmt . Printf ( "Explanation of Recursion: n %s n " , response )

Предварительно созданные функции (цепь мышления)

Используйте функцию ChainOfThought для пошаговых рассуждений:

 question := "What is the result of 15 * 7 + 22?"
response , err := tools . ChainOfThought ( ctx , llm , question )
if err != nil {
    log . Fatalf ( "Failed to perform chain of thought: %v" , err )
}
fmt . Printf ( "Chain of Thought: n %s n " , response )

Работа с примерами

Загрузите примеры непосредственно из файлов:

 examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
    log . Fatalf ( "Failed to read examples: %v" , err )
}

prompt := gollm . NewPrompt ( "Generate a similar example:" ,
    gollm . WithExamples ( examples ... ),
)

response , err := llm . Generate ( ctx , prompt )
if err != nil {
    log . Fatalf ( "Failed to generate example: %v" , err )
}
fmt . Printf ( "Generated Example: n %s n " , response )

Быстрые шаблоны

Создайте шаблоны приглашения на многоразовое использование для последовательного генерации быстрого приглашения:

 // Create a new prompt template
template := gollm . NewPromptTemplate (
    "AnalysisTemplate" ,
    "A template for analyzing topics" ,
    "Provide a comprehensive analysis of {{.Topic}}. Consider the following aspects: n " +
    "1. Historical context n " +
    "2. Current relevance n " +
    "3. Future implications" ,
    gollm . WithPromptOptions (
        gollm . WithDirectives (
            "Use clear and concise language" ,
            "Provide specific examples where appropriate" ,
        ),
        gollm . WithOutput ( "Structure your analysis with clear headings for each aspect." ),
    ),
)

// Use the template to create a prompt
data := map [ string ] interface {}{
    "Topic" : "artificial intelligence in healthcare" ,
}
prompt , err := template . Execute ( data )
if err != nil {
    log . Fatalf ( "Failed to execute template: %v" , err )
}

// Generate a response using the created prompt
response , err := llm . Generate ( ctx , prompt )
if err != nil {
    log . Fatalf ( "Failed to generate response: %v" , err )
}

fmt . Printf ( "Analysis: n %s n " , response )

Структурированный выход (проверка вывода JSON)

Убедитесь, что ваши выходы LLM находятся в действительном формате JSON:

 prompt := gollm . NewPrompt ( "Analyze the pros and cons of remote work." ,
    gollm . WithOutput ( "Respond in JSON format with 'topic', 'pros', 'cons', and 'conclusion' fields." ),
)

response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())
if err != nil {
    log . Fatalf ( "Failed to generate valid analysis: %v" , err )
}

var result AnalysisResult
if err := json . Unmarshal ([] byte ( response ), & result ); err != nil {
    log . Fatalf ( "Failed to parse response: %v" , err )
}

fmt . Printf ( "Analysis: %+v n " , result )

Быстрый оптимизатор

Используйте PromptOptimizer для автоматического уточнения и улучшения ваших подсказок:

 initialPrompt := gollm . NewPrompt ( "Write a short story about a robot learning to love." )
taskDescription := "Generate a compelling short story that explores the theme of artificial intelligence developing emotions."

optimizerInstance := optimizer . NewPromptOptimizer (
    llm ,
    initialPrompt ,
    taskDescription ,
    optimizer . WithCustomMetrics (
        optimizer. Metric { Name : "Creativity" , Description : "How original and imaginative the story is" },
        optimizer. Metric { Name : "Emotional Impact" , Description : "How well the story evokes feelings in the reader" },
    ),
    optimizer . WithRatingSystem ( "numerical" ),
    optimizer . WithThreshold ( 0.8 ),
    optimizer . WithVerbose (),
)

optimizedPrompt , err := optimizerInstance . OptimizePrompt ( ctx )
if err != nil {
    log . Fatalf ( "Optimization failed: %v" , err )
}

fmt . Printf ( "Optimized Prompt: %s n " , optimizedPrompt . Input )

Сравнение модели

Сравните ответы от разных поставщиков LLM или моделей:

 configs := [] * gollm. Config {
    {
        Provider :  "openai" ,
        Model :     "gpt-4o-mini" ,
        APIKey :    os . Getenv ( "OPENAI_API_KEY" ),
        MaxTokens : 500 ,
    },
    {
        Provider :  "anthropic" ,
        Model :     "claude-3-5-sonnet-20240620" ,
        APIKey :    os . Getenv ( "ANTHROPIC_API_KEY" ),
        MaxTokens : 500 ,
    },
    {
        Provider :  "groq" ,
        Model :     "llama-3.1-70b-versatile" ,
        APIKey :    os . Getenv ( "GROQ_API_KEY" ),
        MaxTokens : 500 ,
    },
}

promptText := "Tell me a joke about programming. Respond in JSON format with 'setup' and 'punchline' fields."

validateJoke := func ( joke map [ string ] interface {}) error {
    if joke [ "setup" ] == "" || joke [ "punchline" ] == "" {
        return fmt . Errorf ( "joke must have both a setup and a punchline" )
    }
    return nil
}

results , err := tools . CompareModels ( context . Background (), promptText , validateJoke , configs ... )
if err != nil {
    log . Fatalf ( "Error comparing models: %v" , err )
}

fmt . Println ( tools . AnalyzeComparisonResults ( results ))

Удержание памяти

Включить память для поддержания контекста в разных взаимодействиях:

 llm , err := gollm . NewLLM (
    gollm . SetProvider ( "openai" ),
    gollm . SetModel ( "gpt-3.5-turbo" ),
    gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
    gollm . SetMemory ( 4096 ), // Enable memory with a 4096 token limit
)
if err != nil {
    log . Fatalf ( "Failed to create LLM: %v" , err )
}

ctx := context . Background ()

// First interaction
prompt1 := gollm . NewPrompt ( "What's the capital of France?" )
response1 , err := llm . Generate ( ctx , prompt1 )
if err != nil {
    log . Fatalf ( "Failed to generate response: %v" , err )
}
fmt . Printf ( "Response 1: %s n " , response1 )

// Second interaction, referencing the first
prompt2 := gollm . NewPrompt ( "What's the population of that city?" )
response2 , err := llm . Generate ( ctx , prompt2 )
if err != nil {
    log . Fatalf ( "Failed to generate response: %v" , err )
}
fmt . Printf ( "Response 2: %s n " , response2 )

Лучшие практики

Быстрое инженер :

Используйте NewPrompt() с такими параметрами, как WithContext() , WithDirectives() и WithOutput() для создания хорошо структурированных подсказок.

Пример:

 prompt := gollm . NewPrompt ( "Your main prompt here" ,
    gollm . WithContext ( "Provide relevant context" ),
    gollm . WithDirectives ( "Be concise" , "Use examples" ),
    gollm . WithOutput ( "Specify expected output format" ),
)

Используйте шаблоны быстрого :

Для последовательного генерации быстрого приглашения создайте и используйте объекты PromptTemplate .

Пример:

 template := gollm . NewPromptTemplate (
    "CustomTemplate" ,
    "A template for custom prompts" ,
    "Generate a {{.Type}} about {{.Topic}}" ,
    gollm . WithPromptOptions (
        gollm . WithDirectives ( "Be creative" , "Use vivid language" ),
        gollm . WithOutput ( "Your {{.Type}}:" ),
    ),
)

Предварительно построенные функции :
- Используйте предоставленные функции, такие как ChainOfThought() для сложных задач рассуждения.
- Пример:
```
 response , err := tools . ChainOfThought ( ctx , llm , "Your complex question here" )
```
Работать с примерами :
- Используйте ReadExamplesFromFile() для загрузки примеров из файлов для последовательных выходов.
- Пример:
```
 examples , err := utils . ReadExamplesFromFile ( "examples.txt" )
if err != nil {
    log . Fatalf ( "Failed to read examples: %v" , err )
}
```
Реализовать структурированный выход :
- Используйте WithJSONSchemaValidation() для обеспечения действительных выходов JSON.
- Пример:
```
 response , err := llm . Generate ( ctx , prompt , gollm . WithJSONSchemaValidation ())
```

Оптимизируйте подсказки :

Используйте PromptOptimizer для автоматического уточнения подсказок.

Пример:

 optimizer := optimizer . NewPromptOptimizer ( llm , initialPrompt , taskDescription ,
    optimizer . WithCustomMetrics (
        optimizer. Metric { Name : "Relevance" , Description : "How relevant the response is to the task" },
    ),
    optimizer . WithRatingSystem ( "numerical" ),
    optimizer . WithThreshold ( 0.8 ),
)

Сравните модельные характеристики :
- Используйте CompareModels() для оценки различных моделей или поставщиков.
- Пример:
```
 results , err := tools . CompareModels ( ctx , promptText , validateFunc , configs ... )
```
Реализовать память для контекстуальных взаимодействий :
- Включить удержание памяти для поддержания контекста между взаимодействиями.
- Пример:
```
 llm , err := gollm . NewLLM (
    gollm . SetProvider ( "openai" ),
    gollm . SetModel ( "gpt-3.5-turbo" ),
    gollm . SetMemory ( 4096 ),
)
```
Обработка ошибок и повторения :
- Всегда проверяйте ошибки и настраивайте механизмы повторения.
- Пример:
```
 llm , err := gollm . NewLLM (
    gollm . SetMaxRetries ( 3 ),
    gollm . SetRetryDelay ( time . Second * 2 ),
)
```
Безопасная обработка ключей API :
- Используйте переменные среды для клавиш API.
- Пример:
```
 llm , err := gollm . NewLLM (
    gollm . SetAPIKey ( os . Getenv ( "OPENAI_API_KEY" )),
)
```

Примеры и учебные пособия

Проверьте наш каталог примеров, чтобы узнать больше об использовании примеров, в том числе:

Основное использование
Разные типы быстрого приглашения
Сравнивая поставщиков
Усовершенствованные шаблоны приглашения
Быстрое оптимизация
Json вывода проверка
Смесь агентов

Статус проекта

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

Философия

gollm построен на философии прагматического минимализма и дальновидной простоты:

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

Внося

Мы приветствуем вклад, которые соответствуют нашей философии! Независимо от того, исправляете ли вы ошибку, улучшаете документацию или предлагаете новые функции, ваши усилия ценятся.

Чтобы начать: