ai-core

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/hexagon-codes/ai-core/llm"
    "github.com/hexagon-codes/ai-core/llm/openai"
)

func main() {
    provider := openai.New(os.Getenv("OPENAI_API_KEY"))

    resp, err := provider.Complete(context.Background(), llm.CompletionRequest{
        Model: "gpt-4o",
        Messages: []llm.Message{
            {Role: llm.RoleUser, Content: "你好！"},
        },
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.Content)
}

stream, err := provider.Stream(ctx, llm.CompletionRequest{
    Model: "gpt-4o",
    Messages: llm.NewMessages("你是一个助手", "讲个笑话"),
})
if err != nil {
    panic(err)
}
defer stream.Close()

for chunk := range stream.Chunks() {
    fmt.Print(chunk.Content)
}

import "github.com/hexagon-codes/ai-core/tool"

type WeatherInput struct {
    City string `json:"city" desc:"城市名称" required:"true"`
}

weatherTool := tool.NewFunc("get_weather", "获取城市天气",
    func(ctx context.Context, input WeatherInput) (string, error) {
        return fmt.Sprintf("%s: 晴，25°C", input.City), nil
    },
)

// 转换为 LLM 工具定义
toolDef := llm.NewToolDefinition(
    weatherTool.Name(),
    weatherTool.Description(),
    weatherTool.Schema(),
)

resp, _ := provider.Complete(ctx, llm.CompletionRequest{
    Model:    "gpt-4o",
    Messages: []llm.Message{{Role: llm.RoleUser, Content: "北京天气怎么样？"}},
    Tools:    []llm.ToolDefinition{toolDef},
})

if resp.HasToolCalls() {
    for _, tc := range resp.ToolCalls {
        args, _ := tool.ParseArgs(tc.Arguments)
        result, _ := weatherTool.Execute(ctx, args)
        fmt.Println(result)
    }
}

import (
    "github.com/hexagon-codes/ai-core/llm"
    "github.com/hexagon-codes/ai-core/llm/cache"
)

// 组合多个中间件：重试 → 限流 → 缓存
enhanced := llm.Chain(provider,
    llm.WithRetry(3, time.Second),       // 指数退避重试（自动跳过 401/403 等不可重试错误）
    llm.WithRateLimit(10),               // 10 QPS 令牌桶限流
    llm.WithTimeout(30 * time.Second),   // 请求超时（不影响 Stream）
    llm.WithCache(cache.NewMemoryCache(), nil), // LRU 内存缓存（singleflight 防击穿）
)

resp, _ := enhanced.Complete(ctx, req)

import (
    "github.com/hexagon-codes/ai-core/llm/router"
    "github.com/hexagon-codes/ai-core/llm/openai"
    "github.com/hexagon-codes/ai-core/llm/deepseek"
)

r := router.NewBuilder().
    Add("openai", openai.New(openaiKey)).
    Add("deepseek", deepseek.New(deepseekKey)).
    Strategy(router.StrategyLeastLatency).
    Fallback("deepseek").
    EnableHealthCheck().
    Build()

// 使用路由器（自动选择最优 Provider）
resp, _ := r.Complete(ctx, req)

tokens, err := llm.CountTokensContext(ctx, r, req.Messages)

import (
    "fmt"

    "github.com/hexagon-codes/ai-core/llm"
    "github.com/hexagon-codes/ai-core/llm/compatible"
)

// apiKey 为空时会读取 profile 对应的环境变量，例如 OPENROUTER_API_KEY。
provider, err := compatible.NewProfile(compatible.ProfileOpenRouter, "")
if err != nil {
    panic(err)
}

resp, err := provider.Complete(ctx, llm.CompletionRequest{
    Model: "openai/gpt-4o-mini",
    Messages: []llm.Message{
        {Role: llm.RoleUser, Content: "用三句话解释 RAG"},
    },
})
if err != nil {
    panic(err)
}
fmt.Println(resp.Content)

import (
    "fmt"
    "os"
    "time"

    "github.com/hexagon-codes/ai-core/media/video"
)

seedance := video.NewSeedanceCN(os.Getenv("ARK_API_KEY"))
svc := video.NewService(map[string]video.Provider{
    seedance.Name(): seedance,
}, seedance.Name())

status, err := svc.SubmitAndWait(ctx, "", video.Request{
    Prompt:         "一艘白色帆船穿过清晨海雾",
    Ratio:          "16:9",
    Duration:       5,
    IdempotencyKey: "job-20260702-demo",
}, 2*time.Second)
if err != nil {
    panic(err)
}
fmt.Println(status.VideoURL)

import (
    "fmt"
    "time"

    "github.com/hexagon-codes/ai-core/catalog"
    "github.com/hexagon-codes/ai-core/llm"
    "github.com/hexagon-codes/ai-core/llm/openai"
    "github.com/hexagon-codes/ai-core/media/video"
)

safeOpenAI := openai.New(openaiKey,
    openai.WithNetworkPolicy(llm.PublicNetworkPolicy("api.openai.com")),
    openai.WithRequestTimeout(30*time.Second),
    openai.WithStreamIdleTimeout(90*time.Second),
)

registry := catalog.NewRegistry()
seedance := video.NewSeedanceCN("")
registry.RegisterProvider(seedance)

rows := registry.Find(catalog.Query{
    Modality: catalog.ModalityVideo,
    Feature:  catalog.FeatureAsyncTask,
})
fmt.Println(safeOpenAI.Name(), len(rows))

import "github.com/hexagon-codes/ai-core/memory"

// 缓冲记忆 — 保留最近 N 条消息
buf := memory.NewBuffer(100)
buf.Save(ctx, memory.NewUserEntry("你好"))
buf.Save(ctx, memory.NewAssistantEntry("你好！有什么可以帮助你的？"))

// Get() / Delete() 在条目不存在时返回 memory.ErrNotFound
entry, err := buf.Get(ctx, "some-id")
if errors.Is(err, memory.ErrNotFound) {
    // 处理未找到
}

// 摘要记忆 — 超过阈值自动压缩为摘要（doSummarize 并发安全：Clear + 重新写入在锁内完成）
sum := memory.NewSummaryMemory(summarizer, memory.WithMaxEntries(20))

// 向量记忆 — 语义检索
vec := memory.NewVectorMemory(embedder)
results, _ := vec.SemanticSearch(ctx, "之前讨论的架构方案", 5)

// 多层记忆 — 工作记忆 → 短期记忆 → 长期记忆
// Transfer() 使用独立的 transferMu 锁，避免在调用 Embedder 时阻塞读操作
multi := memory.NewMultiLayerMemory(
    memory.WithSummarizer(summarizer),
    memory.WithEmbedder(embedder),
)