gollm - Go 大型语言模型

gollm是一个Go语言包，旨在帮助您构建自己的AI傀儡。就像传说中的魔像通过神圣词语被赋予生命一样，gollm使您能够利用大型语言模型（LLMs）的力量为AI创造物注入生命。这个包简化并优化了与各种LLM提供商的交互，为AI工程师和开发者提供了一个统一、灵活且强大的接口，以打造他们自己的数字仆从。

文档

目录

• 主要特性
• 实际应用
• 安装
• 快速入门
  • 基本用法
• 快速参考
  • LLM创建和配置
  • 提示创建
  • 生成响应
  • 思维链
  • 提示优化
  • 模型比较
• 高级用法
  • 提示工程
  • 预构建函数（思维链）
  • 使用示例
  • 提示模板
  • 结构化输出（JSON输出验证）
  • 提示优化器
  • 模型比较
  • 记忆保留
• 最佳实践
• 示例和教程
• 项目状态
• 许可证

主要特性

• 多LLM提供商统一API： 使用各种提供商（包括OpenAI、Anthropic Groq和Ollama）塑造您的傀儡的思维。无缝切换GPT-4、GPT-4o-mini、Claude和llama-3.1等模型。
• 轻松切换提供商和模型： 通过简单的函数调用配置首选提供商和模型，塑造您的傀儡的能力。
• 灵活的配置选项： 使用环境变量、基于代码的配置或配置文件自定义您的傀儡的本质，以适应您项目的需求。
• 高级提示工程： 精心设计复杂的指令，有效引导您的傀儡的响应。
• PromptOptimizer： 自动改进和优化您的提示以获得更好的结果，支持自定义指标和不同的评分系统。
• 记忆保留： 在多次交互中保持上下文，实现更连贯的对话。
• 结构化输出和验证： 通过JSON模式生成和验证确保您的傀儡输出一致可靠。
• 提供商比较工具： 测试您的傀儡在不同LLM提供商和模型上执行相同任务的表现。
• 高级AI函数： 使用预构建的函数（如ChainOfThought）赋予您的傀儡复杂推理任务的能力。
• 强大的错误处理和重试机制： 通过内置的重试机制处理API速率限制和瞬时错误，为您的傀儡构建弹性。
• 可扩展架构： 通过扩展对新LLM提供商和功能的支持，轻松扩展您的傀儡的能力。

实际应用

您的gollm驱动的傀儡可以处理广泛的AI驱动任务，包括：

• 内容创作工作流： 为写作项目生成研究摘要、文章创意和精炼段落。
• 复杂推理任务： 使用ChainOfThought函数逐步分解和分析复杂问题。
• 结构化数据生成： 使用可自定义的JSON模式创建和验证复杂数据结构。
• 模型性能分析： 比较不同模型在特定任务上的表现，以优化您的AI流程。
• 提示优化： 自动改进各种任务的提示，从创意写作到技术文档。
• 混合代理： 结合多个LLM提供商的响应，创建多样化且强大的AI代理。

安装

go get github.com/teilomillet/gollm

快速入门

基本用法

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/teilomillet/gollm"
)

func main() {
	llm, err := gollm.NewLLM(
		gollm.SetProvider("openai"),
		gollm.SetModel("gpt-4o-mini"),
		gollm.SetMaxTokens(100),
		gollm.SetAPIKey("your-api-key-here"),
	)
	if err != nil {
		log.Fatalf("创建LLM失败：%v", err)
	}

	ctx := context.Background()

	prompt := gollm.NewPrompt("讲一个关于编程的短笑话。")
	response, err := llm.Generate(ctx, prompt)
	if err != nil {
		log.Fatalf("生成文本失败：%v", err)
	}
	fmt.Printf("响应：%s\n", response)
}

有关更高级的用法，包括研究和内容优化，请查看examples目录。

快速参考

以下是gollm包中最常用函数和选项的快速参考指南：

LLM创建和配置

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("您的提示文本在这里",
    gollm.WithContext("附加上下文"),
    gollm.WithDirectives("保持简洁", "使用示例"),
    gollm.WithOutput("预期输出格式"),
    gollm.WithMaxLength(300),
)

生成响应

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

思维链

response, err := gollm.ChainOfThought(ctx, llm, "您的问题在这里")

提示优化

optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
    gollm.WithCustomMetrics(/* 自定义指标 */),
    gollm.WithRatingSystem("numerical"),
    gollm.WithThreshold(0.8),
)
optimizedPrompt, err := optimizer.OptimizePrompt(ctx)

模型比较

results, err := gollm.CompareModels(ctx, prompt, validateFunc, config1, config2, config3)

高级用法

gollm包提供了一系列高级功能来增强您的AI应用：

• 提示工程
• 预构建函数（如思维链）
• 使用示例
• 提示模板
• 结构化输出（JSON输出验证）
• 提示优化器
• 模型比较
• 记忆保留

以下是如何使用这些高级功能的示例：

提示工程

创建包含多个组件的复杂提示：

prompt := gollm.NewPrompt("解释编程中递归的概念。",
    gollm.WithContext("受众是初级程序员。"),
    gollm.WithDirectives(
        "使用简单的语言，避免行话。",
        "提供一个实际的例子。",
        "解释潜在的陷阱以及如何避免它们。",
    ),
    gollm.WithOutput("使用以下章节结构您的回答：定义、示例、陷阱、最佳实践。"),
    gollm.WithMaxLength(300),
)

response, err := llm.Generate(ctx, prompt)
if err != nil {
    log.Fatalf("生成解释失败：%v", err)
}

fmt.Printf("递归解释：\n%s\n", response)

预构建函数（思维链）

使用ChainOfThought函数进行步骤式推理：

question := "15 * 7 + 22的结果是多少？"
response, err := gollm.ChainOfThought(ctx, llm, question)
if err != nil {
    log.Fatalf("执行思维链失败：%v", err)
}
fmt.Printf("思维链：\n%s\n", response)

使用示例

直接从文件加载示例：

examples, err := gollm.readExamplesFromFile("examples.txt")
if err != nil {
    log.Fatalf("读取示例失败：%v", err)
}

prompt := gollm.NewPrompt("生成一个类似的示例：",
    gollm.WithExamples(examples...),
)

response, err := llm.Generate(ctx, prompt) 如果err不为nil { log.Fatalf("生成示例失败：%v", err) } fmt.Printf("生成的示例：\n%s\n", response)

### 提示模板

创建可重用的提示模板，以实现一致的提示生成：

```go
// 创建新的提示模板
template := gollm.NewPromptTemplate(
    "分析模板",
    "用于分析主题的模板",
    "请对{{.Topic}}进行全面分析。考虑以下几个方面：\n" +
    "1. 历史背景\n" +
    "2. 当前相关性\n" +
    "3. 未来影响",
    gollm.WithPromptOptions(
        gollm.WithDirectives(
            "使用清晰简洁的语言",
            "在适当的地方提供具体例子",
        ),
        gollm.WithOutput("为每个方面使用清晰的标题来组织你的分析。"),
    ),
)

// 使用模板创建提示
data := map[string]interface{}{
    "Topic": "医疗保健中的人工智能",
}
prompt, err := template.Execute(data)
如果err不为nil {
    log.Fatalf("执行模板失败：%v", err)
}

// 使用创建的提示生成回应
response, err := llm.Generate(ctx, prompt)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}

fmt.Printf("分析：\n%s\n", response)

结构化输出（JSON输出验证）

确保你的LLM输出是有效的JSON格式：

prompt := gollm.NewPrompt("分析远程工作的利弊。",
    gollm.WithOutput("以JSON格式回应，包含'topic'、'pros'、'cons'和'conclusion'字段。"),
)

response, err := llm.Generate(ctx, prompt, gollm.WithJSONSchemaValidation())
如果err不为nil {
    log.Fatalf("生成有效分析失败：%v", err)
}

var result AnalysisResult
如果err := json.Unmarshal([]byte(response), &result); err != nil {
    log.Fatalf("解析回应失败：%v", err)
}

fmt.Printf("分析：%+v\n", result)

提示优化器

使用PromptOptimizer自动优化和改进你的提示：

initialPrompt := "写一个关于机器人学会爱的短篇故事。"
taskDescription := "生成一个引人入胜的短篇故事，探讨人工智能发展情感的主题。"

optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
    gollm.WithCustomMetrics(
        gollm.Metric{Name: "创造性", Description: "故事的原创性和想象力"},
        gollm.Metric{Name: "情感影响", Description: "故事唤起读者情感的程度"},
    ),
    gollm.WithRatingSystem("numerical"),
    gollm.WithThreshold(0.8),
    gollm.WithVerbose(),
)

optimizedPrompt, err := optimizer.OptimizePrompt(ctx)
如果err不为nil {
    log.Fatalf("优化失败：%v", err)
}

fmt.Printf("优化后的提示：%s\n", optimizedPrompt)

模型比较

比较不同LLM提供商或模型的回应：

configs := []*gollm.Config{
    {Provider: "openai", Model: "gpt-4o-mini", APIKey: "你的openai-api-key"},
    {Provider: "anthropic", Model: "claude-3-5-sonnet-20240620", APIKey: "你的anthropic-api-key"},
    {Provider: "groq", Model: "llama-3.1-70b-versatile", APIKey: "你的groq-api-key"},
}

prompt := "讲一个关于编程的笑话。以JSON格式回应，包含'setup'和'punchline'字段。"

results, err := gollm.CompareModels(context.Background(), prompt, validateJoke, configs...)
如果err不为nil {
    log.Fatalf("比较模型时出错：%v", err)
}

fmt.Println(gollm.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), // 启用记忆功能，token限制为4096
)
如果err不为nil {
    log.Fatalf("创建LLM失败：%v", err)
}

ctx := context.Background()

// 第一次交互
prompt1 := gollm.NewPrompt("法国的首都是什么？")
response1, err := llm.Generate(ctx, prompt1)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}
fmt.Printf("回应1：%s\n", response1)

// 第二次交互，引用第一次的内容
prompt2 := gollm.NewPrompt("那个城市的人口是多少？")
response2, err := llm.Generate(ctx, prompt2)
如果err不为nil {
    log.Fatalf("生成回应失败：%v", err)
}
fmt.Printf("回应2：%s\n", response2)

最佳实践

1. 提示工程：

   • 使用NewPrompt()函数，配合WithContext()、WithDirectives()和WithOutput()等选项来创建结构良好的提示。
   • 示例：

     prompt := gollm.NewPrompt("你的主要提示在此",
         gollm.WithContext("提供相关上下文"),
         gollm.WithDirectives("简洁", "使用示例"),
         gollm.WithOutput("指定预期的输出格式"),
     )
     

2. 使用提示模板：

   • 为了一致的提示生成，创建并使用PromptTemplate对象。
   • 示例：

     template := gollm.NewPromptTemplate(
         "自定义模板",
         "用于自定义提示的模板",
         "生成一个关于{{.Topic}}的{{.Type}}",
         gollm.WithPromptOptions(
             gollm.WithDirectives("富有创意", "使用生动的语言"),
             gollm.WithOutput("你的{{.Type}}："),
         ),
     )
     

3. 利用预构建函数：

   • 使用提供的函数如ChainOfThought()来处理复杂的推理任务。
   • 示例：

     response, err := gollm.ChainOfThought(ctx, llm, "你的复杂问题在此")
     

4. 使用示例：

   • 使用readExamplesFromFile()函数从文件加载示例，以获得更一致和多样的输出。
   • 示例：

     examples, err := gollm.readExamplesFromFile("examples.txt")
     如果err不为nil {
         log.Fatalf("读取示例失败：%v", err)
     }
     

5. 实现结构化输出：

   • 生成回应时使用WithJSONSchemaValidation()选项以确保有效的JSON输出。
   • 示例：

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

6. 优化提示：

   • 利用PromptOptimizer自动优化和改进你的提示。
   • 示例：

     optimizer := gollm.NewPromptOptimizer(llm, initialPrompt, taskDescription,
         gollm.WithCustomMetrics(
             gollm.Metric{Name: "相关性", Description: "回应与任务的相关程度"},
         ),
         gollm.WithRatingSystem("numerical"),
         gollm.WithThreshold(0.8),
     )
     optimizedPrompt, err := optimizer.OptimizePrompt(ctx)
     

7. 比较模型性能：

   • 使用CompareModels()函数评估不同模型或提供商在特定任务上的表现。
   • 示例：

     results, err := gollm.CompareModels(ctx, prompt, validateFunc, config1, config2, config3)
     

8. 实现上下文记忆：

   • 启用记忆保留功能以在多次交互中维持上下文。
   • 示例：

     llm, err := gollm.NewLLM(
         gollm.SetProvider("openai"),
         gollm.SetModel("gpt-3.5-turbo"),
         gollm.SetMemory(4096), // 启用记忆功能，token限制为4096
     )
     

9. 错误处理和重试：

   • 始终检查gollm函数返回的错误。
   • 配置重试机制以处理暂时性错误和速率限制。
   • 示例：

     llm, err := gollm.NewLLM(
         gollm.SetMaxRetries(3),
         gollm.SetRetryDelay(time.Second * 2),
     )
     

10. 安全处理API密钥：

    • 使用环境变量或安全配置管理来处理API密钥。
    • 示例：

      llm, err := gollm.NewLLM(
          gollm.SetAPIKey(os.Getenv("OPENAI_API_KEY")),
      )
      

遵循这些最佳实践，您可以最有效地使用gollm包，创建更加健壮、高效和易于维护的AI驱动应用程序。

示例和教程

查看我们的示例目录以获取更多使用示例，包括：

• 基本用法
• 不同提示类型
• 比较提供商
• 高级提示模板
• 提示优化
• JSON输出验证
• 混合代理

项目状态

gollm正在积极维护并持续开发中。我们欢迎社区的贡献和反馈。

理念

gollm基于实用主义简约和前瞻性简洁的理念构建：

1. 构建必要的功能：我们根据需求添加功能和能力，避免推测性开发。

2. 简单为先：每个新增功能都应在满足其目的的同时尽可能简单直接。

3. 面向未来兼容：虽然我们不为假设的未来需求构建，但我们会仔细考虑当前变更如何影响未来发展。

4. 可读性至关重要：代码应清晰易懂。如果不是，我们就改进它或详细记录。

5. 模块化设计：每个组件应该只做好一件事，便于理解、测试和未来修改。

这一理念指导我们的开发过程，帮助我们维护一个精简、高效和适应性强的代码库。我们鼓励所有贡献者在提出更改或新功能时牢记这些原则。

贡献

我们欢迎与我们理念一致的贡献！无论您是修复错误、改进文档还是提出新功能，我们都感谢您的努力。

开始贡献：

1. 熟悉我们的理念和开发方法。
2. 查看我们的CONTRIBUTING.md以了解如何贡献的指南。
3. 浏览我们的问题，找到您感兴趣的内容。
4. Fork仓库，进行修改，并提交拉取请求。

请记住，最好的贡献是那些遵循我们实用主义简约和可读性理念的贡献。我们鼓励您在代码中包含示例和清晰的注释。

如果您有任何问题或想法，欢迎开启一个问题或加入我们的社区聊天。我们一直很乐意讨论如何在保持核心原则的同时改进gollm。

感谢您帮助改进gollm！

许可证

本项目采用Apache License 2.0许可 - 有关详细信息，请参阅LICENSE文件。