sdk

package module
v0.2.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 11, 2026 License: MIT Imports: 9 Imported by: 0

README

RAGLite Go SDK

RAGLite 的官方 Go SDK，提供简洁、类型安全的 API 来访问 RAGLite 服务。

特性

  • 🎯 简洁易用 - 流畅的 API 设计，符合 Go 语言习惯
  • 🔒 类型安全 - 完整的类型定义，编译时错误检查
  • 🧩 模块化 - 按服务分离的清晰架构
  • 🚀 高性能 - 支持并发操作，HTTP 连接复用
  • 🛠️ 可扩展 - 灵活的配置选项，易于定制
  • 📝 完整文档 - 详细的代码注释和示例

安装

go get github.com/chaitin/raglite-go-sdk

辅助函数

SDK 提供了便捷的辅助函数：

// Ptr 用于创建指针，简化可选字段的赋值
temperature := sdk.Ptr(0.7)          // *float64
maxTokens := sdk.Ptr(1000)           // *int
description := sdk.Ptr("描述信息")   // *string

快速开始

package main

import (
    "context"
    "fmt"
    "log"

    sdk "github.com/chaitin/raglite-go-sdk"
)

func main() {
    client, err := sdk.NewClient(
        "http://localhost:8080",
    )
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // 健康检查
    health, err := client.Health.Check(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Service: %s, Status: %s\n", health.Service, health.Status)

    // 创建数据集
    dataset, err := client.Datasets.Create(ctx, &sdk.CreateDatasetRequest{
        Name:        "我的知识库",
        Description: "技术文档知识库",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Dataset created: %s\n", dataset.Name)

    // 搜索
    results, err := client.Search.Retrieve(ctx, &sdk.RetrieveRequest{
        Query:     "如何使用 RAGLite",
        DatasetID: dataset.ID,
        TopK:      10,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d results\n", len(results.Results))

    // 问答
    answer, err := client.QA.Ask(ctx, &sdk.QARequest{
        Query:     "RAGLite 的主要功能是什么？",
        DatasetID: dataset.ID,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Answer: %s\n", answer.Answer)
}

核心功能

1. 客户端配置
import "time"

// 基础配置
client, _ := sdk.NewClient("http://localhost:8080")

// 使用 API Key 认证
client, _ := sdk.NewClient(
    "http://localhost:8080",
    sdk.WithAPIKey("your-api-key-here"),
)

// 自定义超时
client, _ := sdk.NewClient(
    "http://localhost:8080",
    sdk.WithTimeout(60 * time.Second),
)

// 组合使用多个选项
client, _ := sdk.NewClient(
    "http://localhost:8080",
    sdk.WithAPIKey("your-api-key-here"),
    sdk.WithTimeout(60 * time.Second),
)

// 自定义 HTTP 客户端
httpClient := &http.Client{
    Timeout: 30 * time.Second,
    Transport: customTransport,
}
client, _ := sdk.NewClient(
    "http://localhost:8080",
    sdk.WithHTTPClient(httpClient),
)
2. AI 模型管理
// 创建模型
model, err := client.Models.Create(ctx, &sdk.CreateModelRequest{
    Name:      "GPT-4",
    ModelType: "chat",
    Provider:  "openai",
    ModelName: "gpt-4",
    Config: sdk.AIModelConfig{
        APIKey:      "your-api-key",
        Temperature: sdk.Ptr(0.7),
    },
    Capabilities: sdk.ModelCapabilities{
        SupportsStreaming: sdk.Ptr(true),
        ContextWindow:     sdk.Ptr(8192),
    },
    IsDefault: true,
})

// 列出模型
models, err := client.Models.List(ctx, &sdk.ListModelsRequest{
    ModelType: "chat",
    Provider:  "openai",
})

// 获取模型详情
model, err := client.Models.Get(ctx, modelID)

// 更新模型
model, err := client.Models.Update(ctx, modelID, &sdk.UpdateModelRequest{
    Name: sdk.Ptr("GPT-4 Turbo"),
})

// 删除模型
err := client.Models.Delete(ctx, modelID)

// 检查模型配置
check, err := client.Models.Check(ctx, &sdk.CheckModelRequest{
    Provider:  "openai",
    ModelName: "gpt-4",
    Config: sdk.AIModelConfig{
        APIKey: "your-api-key",
    },
})

// 根据配置创建或更新模型（Upsert）
// 根据 API Base 和 Model Name 查找，存在则更新，否则创建
result, err := client.Models.Upsert(ctx, &sdk.UpsertModelRequest{
    Name:      "GPT-4",
    ModelType: "chat",
    Provider:  "openai",
    ModelName: "gpt-4",
    Config: sdk.AIModelConfig{
        APIKey:  "your-api-key",
        APIBase: "https://api.openai.com/v1",
    },
    IsDefault: true,
})
// result.Action 为 "created" 或 "updated"
// result.Model 为返回的模型对象
3. 数据集管理
// 创建数据集
dataset, err := client.Datasets.Create(ctx, &sdk.CreateDatasetRequest{
    Name:        "技术文档",
    Description: "公司技术文档知识库",
    Config: sdk.DatasetConfig{
        ChunkSize:    512,
        ChunkOverlap: 50,
    },
})

// 列出数据集
datasets, err := client.Datasets.List(ctx, &sdk.ListDatasetsRequest{
    Status: "active",
})

// 获取数据集详情
dataset, err := client.Datasets.Get(ctx, datasetID)

// 更新数据集
dataset, err := client.Datasets.Update(ctx, datasetID, &sdk.UpdateDatasetRequest{
    Description: sdk.Ptr("更新后的描述"),
})

// 获取统计信息
stats, err := client.Datasets.GetStats(ctx, datasetID)
fmt.Printf("总文档数: %d, 已完成: %d\n", stats.TotalDocuments, stats.CompletedDocs)

// 删除数据集
err := client.Datasets.Delete(ctx, datasetID)
4. 文档管理
import (
    "os"
    "strings"
)

// 上传文档（从文件）
file, _ := os.Open("document.md")
defer file.Close()

resp, err := client.Documents.Upload(ctx, &sdk.UploadDocumentRequest{
    DatasetID: datasetID,
    File:      file,
    Filename:  "document.md",
    Tags:      []string{"技术", "文档"},
    Metadata: map[string]interface{}{
        "author":  "John Doe",
        "version": "1.0",
    },
})

// 上传文档（从字符串）
content := "# 标题\n文档内容..."
resp, err := client.Documents.Upload(ctx, &sdk.UploadDocumentRequest{
    DatasetID: datasetID,
    File:      strings.NewReader(content),
    Filename:  "doc.md",
})

// 更新已有文档（通过提供 DocumentID 替换文档内容）
// 此操作会自动：1) 覆盖 MinIO 文件 2) 更新 PostgreSQL 记录 3) 删除旧向量并重新索引
file, _ := os.Open("updated_document.md")
defer file.Close()

resp, err := client.Documents.Upload(ctx, &sdk.UploadDocumentRequest{
    DatasetID:  datasetID,
    DocumentID: existingDocID,  // 提供已存在的文档 ID
    File:       file,
    Filename:   "updated_document.md",
    Tags:       []string{"技术", "文档", "v2"},
    Metadata: map[string]interface{}{
        "author":  "John Doe",
        "version": "2.0",
    },
})
fmt.Printf("Document %s uploaded: %s\n", resp.DocumentID, resp.Message)

// 列出文档（默认分页）
docs, err := client.Documents.List(ctx, &sdk.ListDocumentsRequest{
    DatasetID: datasetID,
})

// 列出文档（自定义分页）
docs, err := client.Documents.List(ctx, &sdk.ListDocumentsRequest{
    DatasetID: datasetID,
    Page:      2,
    PageSize:  50,
})

// 列出文档（不分页，返回所有文档）
docs, err := client.Documents.List(ctx, &sdk.ListDocumentsRequest{
    DatasetID: datasetID,
    PageSize:  0,
})

// 按文档 ID 列表过滤
docs, err := client.Documents.List(ctx, &sdk.ListDocumentsRequest{
    DatasetID:   datasetID,
    DocumentIDs: []string{docID1, docID2, docID3},
    PageSize:    0, // 不分页，返回所有匹配的文档
})

// 获取文档详情
doc, err := client.Documents.Get(ctx, datasetID, documentID)

// 更新文档的 metadata 和 tags
updatedDoc, err := client.Documents.Update(ctx, &sdk.UpdateDocumentRequest{
    DatasetID:  datasetID,
    DocumentID: documentID,
    Metadata: map[string]interface{}{
        "author":  "Jane Doe",
        "version": "2.0",
        "status":  "published",
    },
    Tags: []string{"技术", "文档", "更新"},
})

// 只更新 metadata
updatedDoc, err := client.Documents.Update(ctx, &sdk.UpdateDocumentRequest{
    DatasetID:  datasetID,
    DocumentID: documentID,
    Metadata: map[string]interface{}{
        "reviewed": true,
    },
})

// 只更新 tags
updatedDoc, err := client.Documents.Update(ctx, &sdk.UpdateDocumentRequest{
    DatasetID:  datasetID,
    DocumentID: documentID,
    Tags: []string{"新标签"},
})

// 删除文档
err := client.Documents.Delete(ctx, datasetID, documentID)

// 批量删除文档
err := client.Documents.BatchDelete(ctx, &sdk.BatchDeleteDocumentsRequest{
    DatasetID:   datasetID,
    DocumentIDs: []string{docID1, docID2, docID3},
})
5. 搜索
// 基础搜索
results, err := client.Search.Retrieve(ctx, &sdk.RetrieveRequest{
    Query:     "RAGLite 是什么",
    DatasetID: datasetID,
    TopK:      10,
})

// 高级搜索（带过滤）
results, err := client.Search.Retrieve(ctx, &sdk.RetrieveRequest{
    Query:               "机器学习算法",
    DatasetID:           datasetID,
    TopK:                20,
    RetrievalMode:       "smart",  // full | smart
    SimilarityThreshold: 0.7,
    Tags:                []string{"AI", "算法"},
    Metadata: map[string]interface{}{
        "category": "research",
    },
})

// 处理搜索结果
for i, result := range results.Results {
    fmt.Printf("%d. [Score: %.3f] %s\n", i+1, result.Score, result.DocumentTitle)
    fmt.Printf("   Section: %s\n", result.SectionTitle)
    fmt.Printf("   Content: %s\n", result.Content)
}
6. 问答
// 基础问答
answer, err := client.QA.Ask(ctx, &sdk.QARequest{
    Query:     "什么是 RAG？",
    DatasetID: datasetID,
})
fmt.Printf("Answer: %s\n", answer.Answer)

// 高级问答
answer, err := client.QA.Ask(ctx, &sdk.QARequest{
    Query:               "RAG 系统如何工作？",
    DatasetID:           datasetID,
    TopK:                5,
    RetrievalMode:       "smart",
    SimilarityThreshold: 0.8,
})

// 查看引用的上下文
fmt.Printf("Answer: %s\n", answer.Answer)
fmt.Printf("Referenced %d contexts:\n", len(answer.Context))
for _, ctx := range answer.Context {
    fmt.Printf("  - %s (Score: %.3f)\n", ctx.DocumentTitle, ctx.Score)
}
7. 生成
// 直接生成答案（不检索，需要手动提供上下文）
result, err := client.Generate.Generate(ctx, &sdk.GenerateRequest{
    Query:     "请总结以下内容",
    Context:   "上下文内容...",
    DatasetID: datasetID,
})
fmt.Printf("Generated: %s\n", result.Answer)

错误处理

SDK 提供了类型化的错误处理：

dataset, err := client.Datasets.Get(ctx, "invalid-id")
if err != nil {
    // 类型断言获取 API 错误
    if apiErr, ok := err.(*sdk.APIError); ok {
        // 检查错误类型
        switch {
        case apiErr.IsNotFound():
            fmt.Println("Dataset not found")
        case apiErr.IsBadRequest():
            fmt.Println("Invalid request")
        case apiErr.IsServerError():
            fmt.Println("Server error")
        default:
            fmt.Printf("API error: %s (status: %d)\n", apiErr.Message, apiErr.StatusCode)
        }
    } else {
        // 其他错误（网络错误等）
        fmt.Printf("Request failed: %v\n", err)
    }
}

并发操作

SDK 是并发安全的，可以在多个 goroutine 中使用：

// 并发上传多个文档
var wg sync.WaitGroup
documents := []string{"doc1.md", "doc2.md", "doc3.md"}

for _, filename := range documents {
    wg.Add(1)
    go func(fn string) {
        defer wg.Done()
        
        file, _ := os.Open(fn)
        defer file.Close()
        
        _, err := client.Documents.Upload(ctx, &sdk.UploadDocumentRequest{
            DatasetID: datasetID,
            File:      file,
            Filename:  fn,
        })
        if err != nil {
            log.Printf("Failed to upload %s: %v", fn, err)
        }
    }(filename)
}

wg.Wait()

完整示例

查看 examples/ 目录获取更多示例：

  • examples/basic/ - 基础使用示例
  • examples/advanced/ - 高级功能示例

API 文档

服务列表

  • Models - AI 模型管理

    • Create(), List(), Get(), Update(), Delete()
    • ListProviderModels(), Check()

  • Datasets - 数据集管理

    • Create(), List(), Get(), Update(), Delete()
    • GetStats()

  • Documents - 文档管理

    • Upload() - 上传/更新文档, List(), Get(), Update(), Delete(), BatchDelete()

  • Search - 搜索服务

    • Search()

  • QA - 问答服务

    • Ask()

  • Generate - 生成服务

    • Generate()

  • Health - 健康检查

    • Check()

最佳实践

1. 使用 Context

始终传递 context 以支持超时和取消：

ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

results, err := client.Search.Retrieve(ctx, req)
2. 复用客户端

客户端是并发安全的，应该复用：

// 好的做法
var globalClient *sdk.Client

func init() {
    globalClient, _ = sdk.NewClient("http://localhost:8080")
}

// 避免每次请求都创建新客户端
func badPractice() {
    client, _ := sdk.NewClient("http://localhost:8080") // ❌
    // ...
}
3. 错误处理

总是检查错误并适当处理：

result, err := client.Search.Retrieve(ctx, req)
if err != nil {
    // 记录日志
    log.Printf("Search failed: %v", err)
    
    // 根据错误类型决定是否重试
    if apiErr, ok := err.(*sdk.APIError); ok {
        if apiErr.IsServerError() {
            // 可以重试
        }
    }
    
    return err
}
4. 资源清理

及时清理不需要的资源：

// 删除测试数据集
defer func() {
    if err := client.Datasets.Delete(ctx, testDatasetID); err != nil {
        log.Printf("Failed to cleanup: %v", err)
    }
}()

配置选项

选项 说明 默认值
WithTimeout() 设置请求超时时间 30s
WithHTTPClient() 使用自定义 HTTP 客户端 默认客户端
WithTransport() 设置自定义 Transport 默认 Transport

常见问题

Q: 如何设置代理？
transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}
client, _ := sdk.NewClient(
    baseURL,
    sdk.WithTransport(transport),
)
Q: 如何启用 TLS？
transport := &http.Transport{
    TLSClientConfig: &tls.Config{
        // TLS 配置
    },
}
client, _ := sdk.NewClient(
    "https://your-server",
    sdk.WithTransport(transport),
)
Q: 如何添加请求日志？
// 自定义 RoundTripper 添加日志
type LoggingTransport struct {
    Transport http.RoundTripper
}

func (t *LoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    log.Printf("Request: %s %s", req.Method, req.URL)
    resp, err := t.Transport.RoundTrip(req)
    if err == nil {
        log.Printf("Response: %d", resp.StatusCode)
    }
    return resp, err
}

client, _ := sdk.NewClient(
    baseURL,
    sdk.WithTransport(&LoggingTransport{
        Transport: http.DefaultTransport,
    }),
)

贡献

欢迎贡献代码、报告问题或提出建议！

许可证

MIT License

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Decode added in v0.1.1 

func Decode[T any](data any) T

Decode 将 map/struct 解码到目标结构体，常用于解析 Metadata

func Ptr 

func Ptr[T any](v T) *T

Ptr 返回值的指针，方便创建指针字段

Types

type AIModel 

type AIModel struct {
	ID           string            `json:"id"`
	Name         string            `json:"name"`
	Description  string            `json:"description"`
	ModelType    string            `json:"model_type"`
	Provider     string            `json:"provider"`
	ModelName    string            `json:"model_name"`
	Config       AIModelConfig     `json:"config"`
	Capabilities ModelCapabilities `json:"capabilities"`
	Status       string            `json:"status"`
	IsDefault    bool              `json:"is_default"`
	CreatedAt    time.Time         `json:"created_at"`
	UpdatedAt    time.Time         `json:"updated_at"`
}

AIModel AI 模型

type AIModelConfig 

type AIModelConfig struct {
	// API 配置
	APIKey     string `json:"api_key,omitempty"`
	APIBase    string `json:"api_base,omitempty"`
	APIHeader  string `json:"api_header,omitempty"`
	APIVersion string `json:"api_version,omitempty"`
	OrgID      string `json:"org_id,omitempty"`

	// 模型参数（Chat Model 专用）
	Temperature      *float64 `json:"temperature,omitempty"`
	MaxTokens        *int     `json:"max_tokens,omitempty"`
	TopP             *float64 `json:"top_p,omitempty"`
	FrequencyPenalty *float64 `json:"frequency_penalty,omitempty"`
	PresencePenalty  *float64 `json:"presence_penalty,omitempty"`

	// 其他配置
	Timeout         int                    `json:"timeout,omitempty"`
	MaxRetries      int                    `json:"max_retries,omitempty"`
	CustomHeaders   map[string]string      `json:"custom_headers,omitempty"`
	ExtraParameters map[string]interface{} `json:"extra_parameters,omitempty"`
}

AIModelConfig AI 模型配置

type APIError 

type APIError struct {
	StatusCode int
	Message    string
}

APIError API 错误

func (*APIError) Error 

func (e *APIError) Error() string

Error 实现 error 接口

func (*APIError) IsBadRequest 

func (e *APIError) IsBadRequest() bool

IsBadRequest 是否为 400 错误

func (*APIError) IsNotFound 

func (e *APIError) IsNotFound() bool

IsNotFound 是否为 404 错误

func (*APIError) IsServerError 

func (e *APIError) IsServerError() bool

IsServerError 是否为服务器错误（5xx）

type APIResponse 

type APIResponse struct {
	Success bool        `json:"success"`
	Message string      `json:"message"`
	Data    interface{} `json:"data"`
}

APIResponse 统一的 API 响应结构

type BatchDeleteDocumentsRequest 

type BatchDeleteDocumentsRequest struct {
	DatasetID   string   `json:"-"`
	DocumentIDs []string `json:"document_ids"`
}

BatchDeleteDocumentsRequest 批量删除文档请求

type ChatMessage added in v0.1.2 

type ChatMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type CheckModelRequest 

type CheckModelRequest struct {
	Provider  string        `json:"provider"`
	ModelName string        `json:"model_name"`
	Config    AIModelConfig `json:"config"`
}

CheckModelRequest 检查模型配置请求

type CheckModelResponse 

type CheckModelResponse struct {
	Valid     bool        `json:"valid"`
	Error     string      `json:"error,omitempty"`
	ModelInfo interface{} `json:"model_info,omitempty"`
}

CheckModelResponse 检查模型响应

type Client 

type Client struct {

	// Services
	Models    *ModelsService
	Datasets  *DatasetsService
	Documents *DocumentsService
	Search    *SearchService
	QA        *QAService
	Generate  *GenerateService
	Health    *HealthService
	// contains filtered or unexported fields
}

Client RAGLite SDK 客户端

func NewClient 

func NewClient(baseURL string, opts ...Option) (*Client, error)

NewClient 创建新的 SDK 客户端

type CreateDatasetRequest 

type CreateDatasetRequest struct {
	Name            string        `json:"name"`
	Description     string        `json:"description,omitempty"`
	DenseModelID    *string       `json:"dense_model_id,omitempty"`
	SparseModelID   *string       `json:"sparse_model_id,omitempty"`
	AnalysisModelID *string       `json:"analysis_model_id,omitempty"`
	RerankerModelID *string       `json:"reranker_model_id,omitempty"`
	VisionModelID   *string       `json:"vision_model_id,omitempty"`
	Config          DatasetConfig `json:"config,omitempty"`
}

CreateDatasetRequest 创建数据集请求

type CreateModelRequest 

type CreateModelRequest struct {
	Name         string            `json:"name"`
	Description  string            `json:"description,omitempty"`
	ModelType    string            `json:"model_type"`
	Provider     string            `json:"provider"`
	ModelName    string            `json:"model_name"`
	Config       AIModelConfig     `json:"config,omitempty"`
	Capabilities ModelCapabilities `json:"capabilities,omitempty"`
	IsDefault    bool              `json:"is_default,omitempty"`
}

CreateRequest 创建模型请求

type Dataset 

type Dataset struct {
	ID              string        `json:"id"`
	Name            string        `json:"name"`
	Description     string        `json:"description"`
	DenseModelID    string        `json:"dense_model_id"`
	SparseModelID   *string       `json:"sparse_model_id,omitempty"`
	AnalysisModelID *string       `json:"analysis_model_id,omitempty"`
	RerankerModelID *string       `json:"reranker_model_id,omitempty"`
	VisionModelID   *string       `json:"vision_model_id,omitempty"`
	Config          DatasetConfig `json:"config"`
	Status          string        `json:"status"`
	CreatedAt       time.Time     `json:"created_at"`
	UpdatedAt       time.Time     `json:"updated_at"`
}

Dataset 数据集

type DatasetConfig 

type DatasetConfig struct {
	ChunkSize    int                    `json:"chunk_size"`             // 块大小（tokens）
	ChunkOverlap int                    `json:"chunk_overlap"`          // 块重叠（tokens）
	IndexParams  map[string]interface{} `json:"index_params,omitempty"` // 索引配置（可选）
}

DatasetConfig 数据集配置

type DatasetStats 

type DatasetStats struct {
	Dataset        Dataset `json:"dataset"`
	TotalDocuments int64   `json:"total_documents"`
	PendingDocs    int64   `json:"pending_docs"`
	ProcessingDocs int64   `json:"processing_docs"`
	CompletedDocs  int64   `json:"completed_docs"`
	FailedDocs     int64   `json:"failed_docs"`
	TotalFileSize  int64   `json:"total_file_size"`
}

DatasetStats 数据集统计

type DatasetsService 

type DatasetsService struct {
	// contains filtered or unexported fields
}

DatasetsService 数据集管理服务

func (*DatasetsService) Create 

func (s *DatasetsService) Create(ctx context.Context, req *CreateDatasetRequest) (*Dataset, error)

Create 创建数据集

func (*DatasetsService) Delete 

func (s *DatasetsService) Delete(ctx context.Context, datasetID string) error

Delete 删除数据集

func (*DatasetsService) Get 

func (s *DatasetsService) Get(ctx context.Context, datasetID string) (*Dataset, error)

Get 获取数据集详情

func (*DatasetsService) GetStats 

func (s *DatasetsService) GetStats(ctx context.Context, datasetID string) (*DatasetStats, error)

GetStats 获取数据集统计信息

func (*DatasetsService) List 

func (s *DatasetsService) List(ctx context.Context, req *ListDatasetsRequest) (*ListDatasetsResponse, error)

List 列出数据集

func (*DatasetsService) Update 

func (s *DatasetsService) Update(ctx context.Context, datasetID string, req *UpdateDatasetRequest) (*Dataset, error)

Update 更新数据集

type Document 

type Document struct {
	ID          string    `json:"id"`
	DatasetID   string    `json:"dataset_id"`
	Title       string    `json:"title"`
	Filename    string    `json:"filename"`
	FilePath    string    `json:"file_path"`
	FileHash    string    `json:"file_hash"`
	FileSize    int64     `json:"file_size"`
	Metadata    JSON      `json:"metadata"`
	Tags        []string  `json:"tags"`
	Status      string    `json:"status"`
	ProgressMsg string    `json:"progress_msg,omitempty"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
}

Document 文档

type DocumentsService 

type DocumentsService struct {
	// contains filtered or unexported fields
}

DocumentsService 文档管理服务

func (*DocumentsService) BatchDelete 

func (s *DocumentsService) BatchDelete(ctx context.Context, req *BatchDeleteDocumentsRequest) error

BatchDelete 批量删除文档

func (*DocumentsService) Delete 

func (s *DocumentsService) Delete(ctx context.Context, datasetID, documentID string) error

Delete 删除文档

func (*DocumentsService) Get 

func (s *DocumentsService) Get(ctx context.Context, datasetID, documentID string) (*Document, error)

Get 获取文档详情

func (*DocumentsService) List 

func (s *DocumentsService) List(ctx context.Context, req *ListDocumentsRequest) (*ListDocumentsResponse, error)

List 列出文档

func (*DocumentsService) Reindex added in v0.2.2 

func (s *DocumentsService) Reindex(ctx context.Context, datasetID, documentID string) (*ReindexResponse, error)

Reindex 重新索引单个文档

func (*DocumentsService) Update 

func (s *DocumentsService) Update(ctx context.Context, req *UpdateDocumentRequest) (*Document, error)

Update 更新文档的 metadata 和 tags

func (*DocumentsService) Upload 

func (s *DocumentsService) Upload(ctx context.Context, req *UploadDocumentRequest) (*UploadDocumentResponse, error)

Upload 上传文档

type GenerateRequest 

type GenerateRequest struct {
	Query     string `json:"query"`
	Context   string `json:"context"`
	DatasetID string `json:"dataset_id"`
}

GenerateRequest 生成请求

type GenerateResponse 

type GenerateResponse struct {
	Answer string `json:"answer"`
}

GenerateResponse 生成响应

type GenerateService 

type GenerateService struct {
	// contains filtered or unexported fields
}

GenerateService 生成服务

func (*GenerateService) Generate 

func (s *GenerateService) Generate(ctx context.Context, req *GenerateRequest) (*GenerateResponse, error)

Generate 生成答案（不检索，直接生成）

type HealthResponse 

type HealthResponse struct {
	Status  string `json:"status"`
	Service string `json:"service"`
}

HealthResponse 健康检查响应

type HealthService 

type HealthService struct {
	// contains filtered or unexported fields
}

HealthService 健康检查服务

func (*HealthService) Check 

func (s *HealthService) Check(ctx context.Context) (*HealthResponse, error)

Check 健康检查

type JSON 

type JSON struct {
	Data interface{}
}

JSON 辅助类型，用于处理 JSON 字段

func (JSON) MarshalJSON 

func (j JSON) MarshalJSON() ([]byte, error)

MarshalJSON 实现 json.Marshaler

func (*JSON) UnmarshalJSON 

func (j *JSON) UnmarshalJSON(data []byte) error

UnmarshalJSON 实现 json.Unmarshaler

type ListDatasetsRequest 

type ListDatasetsRequest struct {
	Status string
}

ListDatasetsRequest 列表查询请求

type ListDatasetsResponse 

type ListDatasetsResponse struct {
	Datasets []Dataset `json:"datasets"`
	Total    int64     `json:"total"`
	Page     int       `json:"page"`
	PageSize int       `json:"page_size"`
}

ListDatasetsResponse 列表响应

type ListDocumentsRequest 

type ListDocumentsRequest struct {
	DatasetID   string
	DocumentIDs []string // 可选：按文档 ID 列表过滤
	Page        int      // 页码，默认 1
	PageSize    int      // 每页数量，默认 20，设为 0 则不分页
}

ListDocumentsRequest 列表查询请求

type ListDocumentsResponse 

type ListDocumentsResponse struct {
	Documents []Document `json:"documents"`
	Total     int64      `json:"total"`
	Page      int        `json:"page"`
	PageSize  int        `json:"page_size"`
}

ListDocumentsResponse 列表响应

type ListModelsRequest 

type ListModelsRequest struct {
	ModelType string
	Provider  string
	Status    string
}

ListModelsRequest 列表查询请求

type ListModelsResponse 

type ListModelsResponse struct {
	Models []AIModel `json:"models"`
	Total  int64     `json:"total"`
}

ListModelsResponse 列表响应

type ListProviderModelsRequest 

type ListProviderModelsRequest struct {
	Provider string                 `json:"provider"`
	Options  map[string]interface{} `json:"options,omitempty"`
}

ListProviderModelsRequest 获取供应商支持的模型列表请求

type ListResponse 

type ListResponse struct {
	Total    int64 `json:"total"`
	Page     int   `json:"page"`
	PageSize int   `json:"page_size"`
}

ListResponse 列表响应

type ModelCapabilities 

type ModelCapabilities struct {
	// Embedding 模型能力
	VectorDimension *int  `json:"vector_dimension,omitempty"`
	MaxInputTokens  *int  `json:"max_input_tokens,omitempty"`
	SupportsBatch   *bool `json:"supports_batch,omitempty"`

	// Chat Model 能力
	SupportsStreaming *bool `json:"supports_streaming,omitempty"`
	SupportsFunctions *bool `json:"supports_functions,omitempty"`
	ContextWindow     *int  `json:"context_window,omitempty"`
	MaxOutputTokens   *int  `json:"max_output_tokens,omitempty"`

	// 通用能力
	CostPer1KTokens *float64 `json:"cost_per_1k_tokens,omitempty"`
}

ModelCapabilities 模型能力参数

type ModelsService 

type ModelsService struct {
	// contains filtered or unexported fields
}

ModelsService AI 模型管理服务

func (*ModelsService) Check 

func (s *ModelsService) Check(ctx context.Context, req *CheckModelRequest) (*CheckModelResponse, error)

Check 检查模型配置

func (*ModelsService) Create 

func (s *ModelsService) Create(ctx context.Context, req *CreateModelRequest) (*AIModel, error)

Create 创建 AI 模型

func (*ModelsService) Delete 

func (s *ModelsService) Delete(ctx context.Context, modelID string) error

Delete 删除模型

func (*ModelsService) Get 

func (s *ModelsService) Get(ctx context.Context, modelID string) (*AIModel, error)

Get 获取模型详情

func (*ModelsService) List 

func (s *ModelsService) List(ctx context.Context, req *ListModelsRequest) (*ListModelsResponse, error)

List 列出 AI 模型

func (*ModelsService) ListProviderModels 

func (s *ModelsService) ListProviderModels(ctx context.Context, req *ListProviderModelsRequest) (interface{}, error)

ListProviderModels 获取供应商支持的模型列表

func (*ModelsService) Update 

func (s *ModelsService) Update(ctx context.Context, modelID string, req *UpdateModelRequest) (*AIModel, error)

Update 更新模型

func (*ModelsService) Upsert 

func (s *ModelsService) Upsert(ctx context.Context, req *UpsertModelRequest) (*UpsertModelResponse, error)

Upsert 根据 API Base 和 Model Name 创建或更新模型 如果找到匹配的模型则更新，否则创建新模型

type Option 

type Option func(*Client)

Option 客户端配置选项

func WithAPIKey 

func WithAPIKey(apiKey string) Option

WithAPIKey 设置 API Key

func WithHTTPClient 

func WithHTTPClient(client *http.Client) Option

WithHTTPClient 设置自定义 HTTP 客户端

func WithTimeout 

func WithTimeout(timeout time.Duration) Option

WithTimeout 设置请求超时时间

func WithTransport 

func WithTransport(transport http.RoundTripper) Option

WithTransport 设置自定义 Transport

type ProviderModel 

type ProviderModel struct {
	ID           string   `json:"id"`
	Name         string   `json:"name"`
	Description  string   `json:"description"`
	Capabilities []string `json:"capabilities"`
}

ProviderModel 供应商模型

type QARequest 

type QARequest struct {
	Query               string  `json:"query"`
	DatasetID           string  `json:"dataset_id"`
	TopK                int     `json:"top_k,omitempty"`
	RetrievalMode       string  `json:"retrieval_mode,omitempty"` // full | smart
	Stream              bool    `json:"stream,omitempty"`
	SimilarityThreshold float64 `json:"similarity_threshold,omitempty"`
}

QARequest 问答请求

type QAResponse 

type QAResponse struct {
	Answer  string         `json:"answer"`
	Context []SearchResult `json:"context"`
}

QAResponse 问答响应

type QAService 

type QAService struct {
	// contains filtered or unexported fields
}

QAService 问答服务

func (*QAService) Ask 

func (s *QAService) Ask(ctx context.Context, req *QARequest) (*QAResponse, error)

Ask 提出问题并获取答案

type ReindexResponse added in v0.2.2 

type ReindexResponse struct {
	Message    string `json:"message"`
	DocumentID string `json:"document_id"`
}

ReindexResponse 重新索引单个文档响应

type RetrieveRequest 

type RetrieveRequest struct {
	Query               string                 `json:"query"`
	DatasetID           string                 `json:"dataset_id"`
	TopK                int                    `json:"top_k,omitempty"`
	RetrievalMode       string                 `json:"retrieval_mode,omitempty"` // full | smart
	SimilarityThreshold float64                `json:"similarity_threshold,omitempty"`
	Metadata            map[string]interface{} `json:"metadata,omitempty"`
	Tags                []string               `json:"tags,omitempty"`
	ChatHistory         []ChatMessage          `json:"chat_history,omitempty"`
	MaxChunksPerDoc     int                    `json:"max_chunks_per_doc,omitempty"`
}

RetrieveRequest 召回请求

type SearchResponse 

type SearchResponse struct {
	Query     string         `json:"query"`
	Results   []SearchResult `json:"results"`
	Total     int            `json:"total"`
	LatencyMs int64          `json:"latency_ms"`
}

SearchResponse 搜索响应

type SearchResult 

type SearchResult struct {
	ChunkID       string                 `json:"chunk_id"`
	DocumentID    string                 `json:"document_id"`
	DocumentTitle string                 `json:"document_title"`
	SectionTitle  string                 `json:"section_title"`
	Content       string                 `json:"content"`
	Score         float64                `json:"score"`
	Metadata      map[string]interface{} `json:"metadata"`
	Tags          []string               `json:"tags"`
	Highlights    []string               `json:"highlights,omitempty"`
}

SearchResult 搜索结果

type SearchService 

type SearchService struct {
	// contains filtered or unexported fields
}

SearchService 搜索服务

func (*SearchService) Retrieve 

func (s *SearchService) Retrieve(ctx context.Context, req *RetrieveRequest) (*SearchResponse, error)

Search 执行搜索

type UpdateDatasetRequest 

type UpdateDatasetRequest struct {
	Name            *string        `json:"name,omitempty"`
	Description     *string        `json:"description,omitempty"`
	DenseModelID    *string        `json:"dense_model_id,omitempty"`
	SparseModelID   *string        `json:"sparse_model_id,omitempty"`
	AnalysisModelID *string        `json:"analysis_model_id,omitempty"`
	RerankerModelID *string        `json:"reranker_model_id,omitempty"`
	VisionModelID   *string        `json:"vision_model_id,omitempty"`
	Config          *DatasetConfig `json:"config,omitempty"`
	Status          *string        `json:"status,omitempty"`
}

UpdateDatasetRequest 更新数据集请求

type UpdateDocumentRequest 

type UpdateDocumentRequest struct {
	DatasetID  string                 `json:"-"`
	DocumentID string                 `json:"-"`
	Metadata   map[string]interface{} `json:"metadata,omitempty"`
	Tags       []string               `json:"tags,omitempty"`
}

UpdateDocumentRequest 更新文档请求

type UpdateModelRequest 

type UpdateModelRequest struct {
	Name         *string            `json:"name,omitempty"`
	Description  *string            `json:"description,omitempty"`
	Provider     *string            `json:"provider,omitempty"`
	ModelName    *string            `json:"model_name,omitempty"`
	Config       *AIModelConfig     `json:"config,omitempty"`
	Capabilities *ModelCapabilities `json:"capabilities,omitempty"`
	Status       *string            `json:"status,omitempty"`
	IsDefault    *bool              `json:"is_default,omitempty"`
	IsActive     *bool              `json:"is_active,omitempty"`
}

UpdateModelRequest 更新模型请求

type UploadDocumentRequest 

type UploadDocumentRequest struct {
	DatasetID  string
	DocumentID string
	File       io.Reader
	Title      string
	Filename   string
	Tags       []string
	Metadata   map[string]interface{}

	// 是否提取文档内容的关键词，会在解析完成后异步通知结果
	ExtractKeywords bool

	// 是否仅提取文档内容的关键词，不会解析文档内容，用于只在给定文档内容中提取关键词的场景
	KeywordsOnlyMode bool
}

UploadDocumentRequest 上传文档请求

type UploadDocumentResponse 

type UploadDocumentResponse struct {
	DocumentID string `json:"document_id"`
	Status     string `json:"status"`
	Message    string `json:"message"`
	Filename   string `json:"filename"`
	Title      string `json:"title"`
	Size       int64  `json:"size"`
}

UploadDocumentResponse 上传文档响应

type UpsertModelRequest 

type UpsertModelRequest struct {
	Name         string            `json:"name,omitempty"`
	Description  string            `json:"description,omitempty"`
	ModelType    string            `json:"model_type"`
	Provider     string            `json:"provider"`
	ModelName    string            `json:"model_name"`
	Config       AIModelConfig     `json:"config"`
	Capabilities ModelCapabilities `json:"capabilities,omitempty"`
	IsDefault    bool              `json:"is_default,omitempty"`
	IsActive     bool              `json:"is_active,omitempty"`
}

UpsertModelRequest 根据配置创建或更新模型请求

type UpsertModelResponse 

type UpsertModelResponse struct {
	Action string  `json:"action"` // "created" 或 "updated"
	Model  AIModel `json:"model"`
}

UpsertModelResponse Upsert 响应

Source Files

View all Source files

Directories

Path Synopsis
examples
advanced command
basic command
basic/doc command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.