pluggedinkit

package module
v1.1.0 Latest Latest
Warning

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

 Go to latest Published: Nov 29, 2025 License: MIT Imports: 11 Imported by: 0

README

Plugged.in Go SDK

Official Go SDK for the Plugged.in Library API. Full support for document management, RAG queries, and file uploads.

Installation

go get github.com/veriteknik/pluggedinkit-go

Quick Start

package main

import (
    "context"
    "fmt"
    "log"

    pluggedin "github.com/veriteknik/pluggedinkit-go"
)

func main() {
    // Initialize client
    client := pluggedin.NewClient("your-api-key")
    // For local development:
    // client := pluggedin.NewClientWithOptions("your-api-key", "http://localhost:12005", nil)

    ctx := context.Background()

    // List documents
    docs, err := client.Documents.List(ctx, &pluggedin.DocumentFilters{
        Source: pluggedin.SourceAll,
        Limit:  10,
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found %d documents\n", docs.Total)

    // Search documents
    results, err := client.Documents.Search(ctx, "machine learning", nil, 10, 0)
    if err != nil {
        log.Fatal(err)
    }
    for _, result := range results.Results {
        fmt.Printf("%s - Relevance: %.2f\n", result.Title, result.RelevanceScore)
    }

    // Query RAG
    answer, err := client.RAG.AskQuestion(ctx, "What are the main features?")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(answer)
}

Features

  • 📄 Document Management - Full CRUD operations for documents
  • 🔍 Semantic Search - AI-powered document search
  • 🤖 RAG Integration - Natural language queries to your knowledge base
  • 📋 Clipboard/Memory - Persistent key-value storage for MCP tools and AI agents
  • 📤 File Uploads - Upload files with progress tracking
  • 🔄 Version Control - Document versioning and history
  • ⚡ Type Safety - Full Go type definitions
  • 🔐 Authentication - Secure API key authentication
  • 🔁 Context Support - Context-aware operations for cancellation
  • 📊 Rate Limiting - Built-in rate limit handling

Authentication

Get your API key from your Plugged.in profile settings:

import (
    "os"
    pluggedin "github.com/veriteknik/pluggedinkit-go"
)

client := pluggedin.NewClient(os.Getenv("PLUGGEDIN_API_KEY"))

Documentation

Document Operations
List Documents
filters := &pluggedin.DocumentFilters{
    Source:   pluggedin.SourceAIGenerated,
    Tags:     []string{"report", "analysis"},
    Sort:     pluggedin.SortDateDesc,
    Limit:    20,
    Offset:   0,
}

response, err := client.Documents.List(ctx, filters)
if err != nil {
    log.Fatal(err)
}

for _, doc := range response.Documents {
    fmt.Printf("%s (%d bytes)\n", doc.Title, doc.FileSize)
}
Get Document
// Get document metadata
doc, err := client.Documents.Get(ctx, "document-id", false, false)
if err != nil {
    log.Fatal(err)
}

// Get document with content
docWithContent, err := client.Documents.Get(ctx, "document-id", true, true)
if err != nil {
    log.Fatal(err)
}

fmt.Println(docWithContent.Content)
Search Documents
filters := map[string]interface{}{
    "modelProvider": "anthropic",
    "dateFrom":      "2024-01-01T00:00:00Z",
    "tags":          "finance,q4",
}

results, err := client.Documents.Search(ctx, "quarterly report", filters, 10, 0)
if err != nil {
    log.Fatal(err)
}

for _, result := range results.Results {
    fmt.Printf("%s\n", result.Title)
    fmt.Printf("  Relevance: %.2f\n", result.RelevanceScore)
    fmt.Printf("  Snippet: %s\n", result.Snippet)
}
Update Document
request := &pluggedin.UpdateDocumentRequest{
    Operation: pluggedin.OpAppend,
    Content:   "\n\n## New Section\n\nAdditional content here.",
    Metadata: map[string]interface{}{
        "changeSummary": "Added implementation details",
        "model": map[string]string{
            "name":     "claude-3-opus",
            "provider": "anthropic",
            "version":  "20240229",
        },
    },
}

response, err := client.Documents.Update(ctx, "document-id", request)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Updated to version %d\n", response.Version)
Create AI Document
request := &pluggedin.CreateDocumentRequest{
    Title:   "API Integration Guide",
    Content: "# API Integration Guide\n\n## Introduction\n\n...",
    Metadata: map[string]interface{}{
        "format":   "md",
        "category": "documentation",
        "tags":     []string{"api", "guide"},
        "model": map[string]string{
            "name":     "gpt-4",
            "provider": "openai",
            "version":  "0613",
        },
        "prompt":     "Create an API integration guide",
        "visibility": "workspace",
    },
}

doc, err := client.Documents.Create(ctx, request)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Created document: %s\n", doc.ID)
RAG Operations
Query Knowledge Base
// Simple query
answer, err := client.RAG.AskQuestion(ctx, "What are the deployment procedures?")
if err != nil {
    log.Fatal(err)
}
fmt.Println(answer)

// Query with sources
result, err := client.RAG.QueryWithSources(
    ctx,
    "Explain the authentication flow",
    "project-uuid", // Optional
)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Answer: %s\n", result.Answer)
fmt.Println("Sources:")
for _, source := range result.Sources {
    fmt.Printf("- %s (relevance: %.0f%%)\n", source.Name, source.Relevance)
}
Find Relevant Documents
documents, err := client.RAG.FindRelevantDocuments(
    ctx,
    "user authentication",
    "project-uuid",
    5, // Top 5 documents
)
if err != nil {
    log.Fatal(err)
}

for _, doc := range documents {
    fmt.Printf("- %s\n", doc.Name)
    if doc.Model != nil {
        fmt.Printf("  By: %s/%s\n", doc.Model.Provider, doc.Model.Name)
    }
}
File Upload Operations
Upload Single File
metadata := &pluggedin.UploadMetadata{
    Name:        "Q4 Report.pdf",
    Description: "Quarterly financial report",
    Tags:        []string{"finance", "q4", "2024"},
    Purpose:     "Financial documentation",
    RelatedTo:   "PROJECT-123",
}

// Progress callback
onProgress := func(percent int) {
    fmt.Printf("Upload progress: %d%%\n", percent)
}

response, err := client.Uploads.UploadFile(
    ctx,
    "./report.pdf",
    metadata,
    onProgress,
)
if err != nil {
    log.Fatal(err)
}

if response.Success {
    fmt.Printf("Uploaded: %s\n", response.DocumentID)

    // Track processing
    if response.UploadID != "" {
        onUpdate := func(status *pluggedin.UploadStatus) {
            fmt.Printf("Status: %s - %s\n", status.Status, status.Message)
        }

        client.Uploads.TrackUpload(ctx, response.UploadID, onUpdate)
    }
}
Upload from Reader
file, err := os.Open("document.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

fileInfo, _ := file.Stat()

response, err := client.Uploads.UploadReader(
    ctx,
    file,
    fileInfo.Size(),
    metadata,
    nil,
)
Batch Upload
files := []pluggedin.FileUpload{
    {
        Path:     "doc1.pdf",
        Metadata: &pluggedin.UploadMetadata{Name: "doc1.pdf", Tags: []string{"batch"}},
    },
    {
        Path:     "doc2.txt",
        Metadata: &pluggedin.UploadMetadata{Name: "doc2.txt", Tags: []string{"batch"}},
    },
}

onProgress := func(current, total int) {
    fmt.Printf("Uploaded %d/%d files\n", current, total)
}

results, err := client.Uploads.UploadBatch(ctx, files, onProgress)
if err != nil {
    log.Fatal(err)
}

for i, result := range results {
    if result.Success {
        fmt.Printf("✓ %s uploaded\n", files[i].Metadata.Name)
    } else {
        fmt.Printf("✗ %s failed: %s\n", files[i].Metadata.Name, result.Error)
    }
}
Clipboard Operations

The clipboard provides persistent key-value storage for MCP tools and AI agents.

Set Named Entry
entry, err := client.Clipboard.Set(ctx, &pluggedin.ClipboardSetRequest{
    Name:        "user_preferences",
    Value:       `{"theme": "dark", "lang": "en"}`,
    ContentType: "application/json",
    Encoding:    "utf-8",
    Visibility:  "private",
    TTLSeconds:  86400, // 24 hours
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Created entry: %s\n", entry.UUID)
fmt.Printf("Source: %s\n", *entry.Source) // "sdk" - automatically set
Get Entry
// By name
entry, err := client.Clipboard.GetByName(ctx, "user_preferences")
if err != nil {
    log.Fatal(err)
}
fmt.Println(entry.Value)

// By index (stack access)
latest, err := client.Clipboard.GetByIndex(ctx, 0)
Push to Stack
entry, err := client.Clipboard.Push(ctx, &pluggedin.ClipboardPushRequest{
    Value:       "Processing step 1 result",
    ContentType: "text/plain",
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Pushed to index: %d\n", *entry.Idx)
Pop from Stack
entry, err := client.Clipboard.Pop(ctx)
if err != nil {
    log.Fatal(err)
}
if entry != nil {
    fmt.Printf("Popped value: %s\n", entry.Value)
}
List and Delete
// List entries with pagination (limit: 100, offset: 0)
response, err := client.Clipboard.List(ctx, 100, 0)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Total: %d, Returned: %d\n", response.Total, len(response.Entries))

for _, entry := range response.Entries {
    var label string
    if entry.Name != nil {
        label = *entry.Name
    } else if entry.Idx != nil {
        label = fmt.Sprintf("idx:%d", *entry.Idx)
    }
    source := pluggedin.DefaultClipboardSource
    if entry.Source != nil {
        source = *entry.Source
    }
    fmt.Printf("%s - source: %s\n", label, source)
}

// Delete by name
name := "old_entry"
deleted, err := client.Clipboard.Delete(ctx, &pluggedin.ClipboardDeleteRequest{
    Name: &name,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Deleted: %v\n", deleted)

// Clear all entries (bulk delete)
result, err := client.Clipboard.ClearAll(ctx)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Cleared %d entries\n", result.Deleted)
Clipboard Entry Structure
type ClipboardEntry struct {
    UUID           string            `json:"uuid"`
    Name           *string           `json:"name"`           // Semantic key
    Idx            *int              `json:"idx"`            // Stack index
    Value          string            `json:"value"`
    ContentType    string            `json:"contentType"`
    Encoding       string            `json:"encoding"`       // utf-8, base64, hex
    SizeBytes      int               `json:"sizeBytes"`
    Visibility     string            `json:"visibility"`     // private, workspace, public
    CreatedByTool  *string           `json:"createdByTool"`
    CreatedByModel *string           `json:"createdByModel"`
    Source         *ClipboardSource  `json:"source,omitempty"` // Auto-set: ui, sdk, mcp
    CreatedAt      time.Time         `json:"createdAt"`
    UpdatedAt      time.Time         `json:"updatedAt"`
    ExpiresAt      *time.Time        `json:"expiresAt"`
}

Note: The Source field is automatically set to ClipboardSourceSDK when using this SDK. It indicates how the entry was created (UI, SDK, or MCP proxy).

Error Handling
doc, err := client.Documents.Get(ctx, "invalid-id", false, false)
if err != nil {
    switch e := err.(type) {
    case *pluggedin.AuthenticationError:
        fmt.Println("Invalid API key")
    case *pluggedin.RateLimitError:
        fmt.Printf("Rate limited. Retry after %d seconds\n", e.RetryAfter)
    case *pluggedin.NotFoundError:
        fmt.Printf("Document not found: %s\n", e.ID)
    case *pluggedin.ValidationError:
        fmt.Printf("Validation error: %s\n", e.Message)
    case *pluggedin.APIError:
        fmt.Printf("API error (%d): %s\n", e.StatusCode, e.Message)
    default:
        fmt.Printf("Error: %v\n", err)
    }
}
Advanced Configuration
import (
    "net/http"
    "time"
)

// Custom HTTP client
httpClient := &http.Client{
    Timeout: 120 * time.Second,
    // Add custom transport, etc.
}

client := pluggedin.NewClientWithOptions(
    "your-api-key",
    "https://plugged.in",
    httpClient,
)

// Update API key at runtime
client.SetAPIKey("new-api-key")

// Change base URL
client.SetBaseURL("http://localhost:12005")

Environment Variables

Store your API key securely:

export PLUGGEDIN_API_KEY=your-api-key
export PLUGGEDIN_BASE_URL=https://plugged.in

import (
    "os"
    pluggedin "github.com/veriteknik/pluggedinkit-go"
)

client := pluggedin.NewClientWithOptions(
    os.Getenv("PLUGGEDIN_API_KEY"),
    os.Getenv("PLUGGEDIN_BASE_URL"),
    nil,
)

Rate Limiting

The SDK handles rate limiting automatically:

  • API Endpoints: 60 requests per minute
  • Document Search: 10 requests per hour for AI document creation
  • RAG Queries: Subject to plan limits

Examples

See the examples directory for complete working examples:

Contributing

Contributions are welcome! Please see our Contributing Guide for details.

License

MIT - see LICENSE for details.

Support

Changelog

See CHANGELOG.md for release history.

Documentation

Index

Constants

View Source 
const (
	DefaultBaseURL = "https://plugged.in"
	DefaultTimeout = 60 * time.Second
	Version        = "1.0.1"
)
View Source 
const DefaultClipboardSource = ClipboardSourceUI

DefaultClipboardSource is the default source for backward compatibility

Variables

This section is empty.

Functions

This section is empty.

Types

type APIError 

type APIError struct {
	StatusCode int
	Message    string
	Details    interface{}
}

APIError represents an API error

func (*APIError) Error 

func (e *APIError) Error() string

type AuthenticationError 

type AuthenticationError struct {
	Message string
}

AuthenticationError represents an authentication error

func (*AuthenticationError) Error 

func (e *AuthenticationError) Error() string

type ClearAllResult 

type ClearAllResult struct {
	Deleted int  `json:"deleted"` // Number of entries deleted
	Success bool `json:"success"` // Whether the operation was successful
}

ClearAllResult provides structured feedback from clearing all clipboard entries

type Client 

type Client struct {

	// Services
	Clipboard *ClipboardService
	Documents *DocumentsService
	RAG       *RAGService
	Uploads   *UploadsService
	// contains filtered or unexported fields
}

Client is the main Plugged.in API client

func NewClient 

func NewClient(apiKey string) *Client

NewClient creates a new Plugged.in API client

func NewClientWithOptions 

func NewClientWithOptions(apiKey, baseURL string, httpClient *http.Client) *Client

NewClientWithOptions creates a new client with custom options

func (*Client) SetAPIKey 

func (c *Client) SetAPIKey(apiKey string)

SetAPIKey updates the API key

func (*Client) SetBaseURL 

func (c *Client) SetBaseURL(baseURL string)

SetBaseURL updates the base URL

type ClipboardDeleteRequest 

type ClipboardDeleteRequest struct {
	Name *string `json:"name,omitempty"`
	Idx  *int    `json:"idx,omitempty"`
}

ClipboardDeleteRequest represents a request to delete a clipboard entry

type ClipboardDeleteResponse 

type ClipboardDeleteResponse struct {
	Success bool   `json:"success"`
	Deleted bool   `json:"deleted,omitempty"`
	Error   string `json:"error,omitempty"`
}

ClipboardDeleteResponse represents the response from clipboard delete operations

type ClipboardEncoding 

type ClipboardEncoding string

ClipboardEncoding represents clipboard content encoding 

const (
	EncodingUTF8   ClipboardEncoding = "utf-8"
	EncodingBase64 ClipboardEncoding = "base64"
	EncodingHex    ClipboardEncoding = "hex"
)

type ClipboardEntry 

type ClipboardEntry struct {
	UUID           string              `json:"uuid"`
	Name           *string             `json:"name,omitempty"`
	Idx            *int                `json:"idx,omitempty"`
	Value          string              `json:"value"`
	ContentType    string              `json:"contentType"`
	Encoding       ClipboardEncoding   `json:"encoding"`
	SizeBytes      int                 `json:"sizeBytes"`
	Visibility     ClipboardVisibility `json:"visibility"`
	CreatedByTool  *string             `json:"createdByTool,omitempty"`
	CreatedByModel *string             `json:"createdByModel,omitempty"`
	// Source is optional for backward compatibility with older API responses
	Source    *ClipboardSource `json:"source,omitempty"`
	CreatedAt time.Time        `json:"createdAt"`
	UpdatedAt time.Time        `json:"updatedAt"`
	ExpiresAt *time.Time       `json:"expiresAt,omitempty"`
}

ClipboardEntry represents a clipboard entry

type ClipboardGetFilters 

type ClipboardGetFilters struct {
	Name *string `json:"name,omitempty"`
	Idx  *int    `json:"idx,omitempty"`
}

ClipboardGetFilters represents filters for getting a clipboard entry

type ClipboardListResponse 

type ClipboardListResponse struct {
	Success bool             `json:"success"`
	Entries []ClipboardEntry `json:"entries"`
	Total   int              `json:"total,omitempty"`
	Limit   int              `json:"limit,omitempty"`
	Offset  int              `json:"offset,omitempty"`
}

ClipboardListResponse represents the response from listing clipboard entries

type ClipboardPushRequest 

type ClipboardPushRequest struct {
	Value          string              `json:"value"`
	ContentType    string              `json:"contentType,omitempty"`
	Encoding       ClipboardEncoding   `json:"encoding,omitempty"`
	Visibility     ClipboardVisibility `json:"visibility,omitempty"`
	CreatedByTool  string              `json:"createdByTool,omitempty"`
	CreatedByModel string              `json:"createdByModel,omitempty"`
	TTLSeconds     int                 `json:"ttlSeconds,omitempty"`
}

ClipboardPushRequest represents a request to push to indexed clipboard

type ClipboardResponse 

type ClipboardResponse struct {
	Success bool            `json:"success"`
	Entry   *ClipboardEntry `json:"entry,omitempty"`
	Error   string          `json:"error,omitempty"`
}

ClipboardResponse represents the response from clipboard operations

type ClipboardService 

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

ClipboardService handles clipboard-related operations

func (*ClipboardService) ClearAll 

func (s *ClipboardService) ClearAll(ctx context.Context) (*ClearAllResult, error)

ClearAll clears all clipboard entries using bulk delete API. Returns a ClearAllResult with the count of deleted entries and success status.

func (*ClipboardService) Delete 

func (s *ClipboardService) Delete(ctx context.Context, req *ClipboardDeleteRequest) (bool, error)

Delete deletes a clipboard entry by name or index

func (*ClipboardService) DeleteByIndex 

func (s *ClipboardService) DeleteByIndex(ctx context.Context, idx int) (bool, error)

DeleteByIndex deletes a clipboard entry by index (convenience method)

func (*ClipboardService) DeleteByName 

func (s *ClipboardService) DeleteByName(ctx context.Context, name string) (bool, error)

DeleteByName deletes a clipboard entry by name (convenience method)

func (*ClipboardService) Get 

func (s *ClipboardService) Get(ctx context.Context, filters *ClipboardGetFilters) (*ClipboardEntry, error)

Get retrieves a clipboard entry by name or index. Returns (nil, nil) if the entry is not found. Returns (nil, error) if there was an actual error.

func (*ClipboardService) GetByIndex 

func (s *ClipboardService) GetByIndex(ctx context.Context, idx int) (*ClipboardEntry, error)

GetByIndex retrieves a clipboard entry by index (convenience method)

func (*ClipboardService) GetByName 

func (s *ClipboardService) GetByName(ctx context.Context, name string) (*ClipboardEntry, error)

GetByName retrieves a clipboard entry by name (convenience method)

func (*ClipboardService) List 

func (s *ClipboardService) List(ctx context.Context, limit, offset int) (*ClipboardListResponse, error)

List retrieves clipboard entries with optional pagination. limit: maximum number of entries to return (1-100, default: 50) offset: number of entries to skip (default: 0)

func (*ClipboardService) Pop 

func (s *ClipboardService) Pop(ctx context.Context) (*ClipboardEntry, error)

Pop pops the last indexed entry from clipboard. Returns (nil, nil) if the clipboard is empty. Returns (nil, error) if there was an actual error.

func (*ClipboardService) Push 

func (s *ClipboardService) Push(ctx context.Context, req *ClipboardPushRequest) (*ClipboardEntry, error)

Push pushes a value to the indexed clipboard (auto-increment index)

func (*ClipboardService) Set 

func (s *ClipboardService) Set(ctx context.Context, req *ClipboardSetRequest) (*ClipboardEntry, error)

Set sets a named clipboard entry (upsert)

type ClipboardSetRequest 

type ClipboardSetRequest struct {
	Name           string              `json:"name"`
	Value          string              `json:"value"`
	ContentType    string              `json:"contentType,omitempty"`
	Encoding       ClipboardEncoding   `json:"encoding,omitempty"`
	Visibility     ClipboardVisibility `json:"visibility,omitempty"`
	CreatedByTool  string              `json:"createdByTool,omitempty"`
	CreatedByModel string              `json:"createdByModel,omitempty"`
	TTLSeconds     int                 `json:"ttlSeconds,omitempty"`
}

ClipboardSetRequest represents a request to set a named clipboard entry

type ClipboardSource 

type ClipboardSource string

ClipboardSource represents the source of clipboard data 

const (
	ClipboardSourceUI  ClipboardSource = "ui"
	ClipboardSourceSDK ClipboardSource = "sdk"
	ClipboardSourceMCP ClipboardSource = "mcp"
)

type ClipboardVisibility 

type ClipboardVisibility string

ClipboardVisibility represents clipboard visibility 

const (
	ClipboardVisibilityPrivate   ClipboardVisibility = "private"
	ClipboardVisibilityWorkspace ClipboardVisibility = "workspace"
	ClipboardVisibilityPublic    ClipboardVisibility = "public"
)

type CreateDocumentRequest 

type CreateDocumentRequest struct {
	Title    string                 `json:"title"`
	Content  string                 `json:"content"`
	Format   string                 `json:"format,omitempty"`
	Category string                 `json:"category,omitempty"`
	Tags     []string               `json:"tags,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

CreateDocumentRequest represents a request to create a document

type Document 

type Document struct {
	ID                string             `json:"id"`
	Title             string             `json:"title"`
	Description       string             `json:"description,omitempty"`
	FileName          string             `json:"fileName"`
	FileSize          int64              `json:"fileSize"`
	MimeType          string             `json:"mimeType"`
	Tags              []string           `json:"tags,omitempty"`
	Source            DocumentSource     `json:"source"`
	Visibility        DocumentVisibility `json:"visibility"`
	Version           int                `json:"version"`
	CreatedAt         time.Time          `json:"createdAt"`
	UpdatedAt         time.Time          `json:"updatedAt"`
	AIMetadata        map[string]any     `json:"aiMetadata,omitempty"`
	ModelAttributions []ModelAttribution `json:"modelAttributions,omitempty"`
	Content           string             `json:"content,omitempty"`
	ContentEncoding   string             `json:"contentEncoding,omitempty"`
	ContentHash       string             `json:"contentHash,omitempty"`
	ParentDocumentID  string             `json:"parentDocumentId,omitempty"`
}

Document represents a document in the library

type DocumentCategory 

type DocumentCategory string

DocumentCategory represents document category 

const (
	CategoryReport        DocumentCategory = "report"
	CategoryAnalysis      DocumentCategory = "analysis"
	CategoryDocumentation DocumentCategory = "documentation"
	CategoryGuide         DocumentCategory = "guide"
	CategoryResearch      DocumentCategory = "research"
	CategoryCode          DocumentCategory = "code"
	CategoryOther         DocumentCategory = "other"
)

type DocumentFilters 

type DocumentFilters struct {
	Source        DocumentSource   `json:"source,omitempty"`
	Tags          []string         `json:"tags,omitempty"`
	Category      DocumentCategory `json:"category,omitempty"`
	DateFrom      *time.Time       `json:"dateFrom,omitempty"`
	DateTo        *time.Time       `json:"dateTo,omitempty"`
	ModelProvider string           `json:"modelProvider,omitempty"`
	ModelName     string           `json:"modelName,omitempty"`
	SearchQuery   string           `json:"searchQuery,omitempty"`
	Sort          SortOrder        `json:"sort,omitempty"`
	Limit         int              `json:"limit,omitempty"`
	Offset        int              `json:"offset,omitempty"`
}

DocumentFilters represents filters for listing documents

type DocumentFormat 

type DocumentFormat string

DocumentFormat represents document format 

const (
	FormatMarkdown DocumentFormat = "md"
	FormatText     DocumentFormat = "txt"
	FormatJSON     DocumentFormat = "json"
	FormatHTML     DocumentFormat = "html"
)

type DocumentSource 

type DocumentSource string

DocumentSource represents the source of a document 

const (
	SourceAll         DocumentSource = "all"
	SourceUpload      DocumentSource = "upload"
	SourceAIGenerated DocumentSource = "ai_generated"
	SourceAPI         DocumentSource = "api"
)

type DocumentVisibility 

type DocumentVisibility string

DocumentVisibility represents document visibility 

const (
	VisibilityPrivate   DocumentVisibility = "private"
	VisibilityWorkspace DocumentVisibility = "workspace"
	VisibilityPublic    DocumentVisibility = "public"
)

type DocumentsService 

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

DocumentsService handles document-related operations

func (*DocumentsService) Create 

func (s *DocumentsService) Create(ctx context.Context, req *CreateDocumentRequest) (*Document, error)

Create creates a new AI-generated document

func (*DocumentsService) Delete 

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

Delete deletes a document

func (*DocumentsService) Download 

func (s *DocumentsService) Download(ctx context.Context, documentID string, projectUUID string) ([]byte, error)

Download downloads a document file

func (*DocumentsService) Get 

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

Get retrieves a specific document by ID

func (*DocumentsService) List 

func (s *DocumentsService) List(ctx context.Context, filters *DocumentFilters) (*ListDocumentsResponse, error)

List retrieves a list of documents with optional filters

func (*DocumentsService) Search 

func (s *DocumentsService) Search(ctx context.Context, query string, filters map[string]interface{}, limit, offset int) (*SearchResponse, error)

Search performs a semantic search on documents

func (*DocumentsService) Update 

func (s *DocumentsService) Update(ctx context.Context, documentID string, req *UpdateDocumentRequest) (*UpdateDocumentResponse, error)

Update updates an existing document

type ErrorResponse 

type ErrorResponse struct {
	Error   string      `json:"error"`
	Message string      `json:"message"`
	Details interface{} `json:"details,omitempty"`
}

ErrorResponse represents an error response from the API

type FileUpload 

type FileUpload struct {
	Path     string
	Metadata *UploadMetadata
}

FileUpload represents a file to upload (retained for compatibility).

type ListDocumentsResponse 

type ListDocumentsResponse struct {
	Documents []Document `json:"documents"`
	Total     int        `json:"total"`
	Limit     int        `json:"limit"`
	Offset    int        `json:"offset"`
}

ListDocumentsResponse represents the response from listing documents

type ModelAttribution 

type ModelAttribution struct {
	ModelName        string         `json:"modelName"`
	ModelProvider    string         `json:"modelProvider"`
	ContributionType string         `json:"contributionType"`
	Timestamp        time.Time      `json:"timestamp"`
	Metadata         map[string]any `json:"metadata,omitempty"`
}

ModelAttribution represents model contribution metadata

type NotFoundError 

type NotFoundError struct {
	Resource string
	ID       string
}

NotFoundError represents a not found error

func (*NotFoundError) Error 

func (e *NotFoundError) Error() string

type ProgressCallback 

type ProgressCallback func(percent int)

ProgressCallback is retained for backwards compatibility.

type RAGDocumentReference 

type RAGDocumentReference struct {
	DocumentID string `json:"documentId"`
	Source     string `json:"source,omitempty"`
}

RAGDocumentReference represents a matched document reference

type RAGResponse 

type RAGResponse struct {
	Success     bool     `json:"success"`
	Answer      string   `json:"answer,omitempty"`
	Sources     []string `json:"sources,omitempty"`
	DocumentIDs []string `json:"documentIds,omitempty"`
	Error       string   `json:"error,omitempty"`
}

RAGResponse represents a RAG query response

type RAGService 

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

RAGService handles RAG-related operations

func (*RAGService) AskQuestion 

func (s *RAGService) AskQuestion(ctx context.Context, query string) (string, error)

AskQuestion performs a simple RAG query and returns the answer text.

func (*RAGService) CheckAvailability 

func (s *RAGService) CheckAvailability(ctx context.Context) (map[string]interface{}, error)

CheckAvailability checks if the RAG service is reachable.

func (*RAGService) FindRelevantDocuments 

func (s *RAGService) FindRelevantDocuments(ctx context.Context, query, _ string, limit int) ([]RAGDocumentReference, error)

FindRelevantDocuments finds documents relevant to a query.

func (*RAGService) GetStorageStats 

func (s *RAGService) GetStorageStats(ctx context.Context, userID string) (*RAGStorageStats, error)

GetStorageStats gets storage statistics for RAG.

func (*RAGService) Query 

func (s *RAGService) Query(ctx context.Context, query string) (*RAGResponse, error)

Query performs a RAG query and returns the raw response.

func (*RAGService) QueryWithSources 

func (s *RAGService) QueryWithSources(ctx context.Context, query, _ string) (*RAGResponse, error)

QueryWithSources performs a RAG query and returns the response with metadata.

type RAGStorageStats 

type RAGStorageStats struct {
	DocumentsCount     int     `json:"documents_count"`
	TotalChunks        int     `json:"total_chunks"`
	EstimatedStorageMB float64 `json:"estimated_storage_mb"`
	VectorsCount       int     `json:"vectors_count,omitempty"`
	EmbeddingDimension int     `json:"embedding_dimension,omitempty"`
	IsEstimate         bool    `json:"is_estimate,omitempty"`
}

RAGStorageStats represents storage metrics returned by the API

type RateLimitError 

type RateLimitError struct {
	Message    string
	RetryAfter int
}

RateLimitError represents a rate limit error

func (*RateLimitError) Error 

func (e *RateLimitError) Error() string

type SearchResponse 

type SearchResponse struct {
	Results []SearchResult `json:"results"`
	Total   int            `json:"total"`
	Limit   int            `json:"limit"`
	Offset  int            `json:"offset"`
	HasMore bool           `json:"hasMore"`
}

SearchResponse represents the response from searching documents

type SearchResult 

type SearchResult struct {
	ID                string             `json:"id"`
	Title             string             `json:"title"`
	Description       string             `json:"description,omitempty"`
	Snippet           string             `json:"snippet"`
	RelevanceScore    float64            `json:"relevanceScore"`
	Source            string             `json:"source"`
	AIMetadata        map[string]any     `json:"aiMetadata,omitempty"`
	Tags              []string           `json:"tags,omitempty"`
	Visibility        string             `json:"visibility"`
	CreatedAt         time.Time          `json:"createdAt"`
	ModelAttributions []ModelAttribution `json:"modelAttributions,omitempty"`
}

SearchResult represents a search result

type SortOrder 

type SortOrder string

SortOrder represents sort order for listing 

const (
	SortDateDesc SortOrder = "date_desc"
	SortDateAsc  SortOrder = "date_asc"
	SortTitle    SortOrder = "title"
	SortSize     SortOrder = "size"
)

type UpdateDocumentRequest 

type UpdateDocumentRequest struct {
	Operation UpdateOperation        `json:"operation"`
	Content   string                 `json:"content"`
	Metadata  map[string]interface{} `json:"metadata,omitempty"`
}

UpdateDocumentRequest represents a request to update a document

type UpdateDocumentResponse 

type UpdateDocumentResponse struct {
	Success     bool   `json:"success"`
	DocumentID  string `json:"documentId"`
	Version     int    `json:"version"`
	FileWritten bool   `json:"fileWritten"`
	Message     string `json:"message,omitempty"`
}

UpdateDocumentResponse represents the response from updating a document

type UpdateOperation 

type UpdateOperation string

UpdateOperation represents update operations 

const (
	OpReplace UpdateOperation = "replace"
	OpAppend  UpdateOperation = "append"
	OpPrepend UpdateOperation = "prepend"
)

type UploadMetadata 

type UploadMetadata struct {
	Name        string   `json:"name"`
	Description string   `json:"description,omitempty"`
	Tags        []string `json:"tags,omitempty"`
	Purpose     string   `json:"purpose,omitempty"`
	RelatedTo   string   `json:"relatedTo,omitempty"`
	ProjectID   string   `json:"projectId,omitempty"`
}

UploadMetadata represents metadata for file uploads

type UploadResponse 

type UploadResponse struct {
	Success    bool   `json:"success"`
	DocumentID string `json:"documentId,omitempty"`
	UploadID   string `json:"uploadId,omitempty"`
	Error      string `json:"error,omitempty"`
	Message    string `json:"message,omitempty"`
}

UploadResponse represents the response from uploading a file

type UploadStatus 

type UploadStatus struct {
	UploadID string `json:"uploadId"`
	Status   string `json:"status"`
	Message  string `json:"message"`
	Progress int    `json:"progress"`
}

UploadStatus represents the status of an upload

type UploadsService 

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

UploadsService handles upload operations. The public API no longer exposes direct binary upload endpoints. The methods now return informative errors to help consumers migrate to the supported flows.

func (*UploadsService) TrackUpload 

func (s *UploadsService) TrackUpload(ctx context.Context, uploadID string, onUpdate func(status *UploadStatus)) error

TrackUpload is no longer supported.

func (*UploadsService) UploadBatch 

func (s *UploadsService) UploadBatch(ctx context.Context, files []FileUpload, onProgress func(current, total int)) ([]UploadResponse, error)

UploadBatch is no longer supported.

func (*UploadsService) UploadFile 

func (s *UploadsService) UploadFile(ctx context.Context, filePath string, metadata *UploadMetadata, onProgress ProgressCallback) (*UploadResponse, error)

UploadFile is no longer supported.

func (*UploadsService) UploadReader 

func (s *UploadsService) UploadReader(ctx context.Context, reader io.Reader, size int64, metadata *UploadMetadata, onProgress ProgressCallback) (*UploadResponse, error)

UploadReader is no longer supported.

type ValidationError 

type ValidationError struct {
	Field   string
	Message string
}

ValidationError represents a validation error

func (*ValidationError) Error 

func (e *ValidationError) Error() string

Source Files

View all Source files

Directories

Path Synopsis
examples
basic 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.