knowledge

type BulkIngestDocResult struct {
	Index         int    `json:"index"`
	DocumentID    string `json:"document_id,omitempty"`
	Title         string `json:"title,omitempty"`
	ChunksCreated int    `json:"chunks_created"`
	Success       bool   `json:"success"`
	Error         string `json:"error,omitempty"`
}

type BulkIngestDocument struct {
	Content     string            `json:"content"`
	Title       string            `json:"title,omitempty"`
	Source      string            `json:"source,omitempty"`
	ContentType string            `json:"content_type,omitempty"`
	Metadata    map[string]string `json:"metadata,omitempty"`
}

type BulkIngestOpts struct {
	ChunkConfig     *types.ChunkConfig                     // Override collection's default config
	Concurrency     int                                    // Number of concurrent workers (0 = default 4)
	OnProgress      func(completed, total int, doc string) // Optional progress callback
	ContinueOnError bool                                   // Continue processing on individual document errors
}

type BulkIngestResult struct {
	CollectionID   string                 `json:"collection_id"`
	TotalDocuments int                    `json:"total_documents"`
	Succeeded      int                    `json:"succeeded"`
	Failed         int                    `json:"failed"`
	TotalChunks    int                    `json:"total_chunks"`
	Documents      []*BulkIngestDocResult `json:"documents"`
}

type ChunkOutput struct {
	Content    string
	Index      int
	TokenCount int
}

type ChunkStrategy string

type Chunker interface {
	// Chunk splits content into chunks based on the configured strategy.
	Chunk(content string, cfg types.ChunkConfig) []ChunkOutput
}

type CreateCollectionOpts struct {
	Name        string             // Required: collection name
	Description string             // Optional description
	ChunkConfig *types.ChunkConfig // Chunk configuration (uses default if nil)
}

type DefaultChunker struct{}

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

type ExtractionEnqueuer interface {
	EnqueueForExtraction(ctx context.Context, namespace, sourceType, sourceID, content string) error
}

type IngestOpts struct {
	Title       string             // Optional document title
	Source      string             // Source URL or identifier
	ContentType string             // "text", "markdown", "html"
	Metadata    map[string]string  // Optional metadata
	ChunkConfig *types.ChunkConfig // Override collection's default config
}

type IngestResult struct {
	DocumentID    string `json:"document_id"`
	ChunksCreated int    `json:"chunks_created"`
	CollectionID  string `json:"collection_id"`
}

type SearchMode string

type SearchOpts struct {
	CollectionID  *string           // Optional: limit to specific collection
	TopK          int               // Number of results (0 = default 10)
	MinScore      float64           // Minimum similarity score (0-1)
	Filters       map[string]string // Metadata filters
	ContextWindow int               // Chunks before/after to include (0 = none)
	SearchMode    SearchMode        // Search mode: "vector" (default), "hybrid", or "text"
	Alpha         float64           // Hybrid search weight: 0=pure text, 1=pure vector, 0.5=equal (default: 0.5)
}

type SearchResult struct {
	Results    []*types.ChunkResult `json:"results"`
	Query      string               `json:"query"`
	TotalFound int                  `json:"total_found"`
}

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

type SemanticChunkerOption func(*SemanticChunker)