config

type Cache interface {
	Get(ctx interface{}, key string) (*Response, bool)
	Set(ctx interface{}, key string, value *Response, expiration interface{})
}

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

type ConversationManager struct {
}

type EngineConfig struct {
	Parsers             map[string]parser.Parser   // Map of file extensions to parsers
	DefaultParser       parser.Parser              // Default parser for unknown file types
	Embedder            embedding.Provider         // Embedding model provider
	Store               vectorstore.Store          // Vector storage backend
	LLM                 llm.Client                 // LLM client for generation
	Retriever           *retrieval.HybridRetriever // Hybrid retrieval (vector + keyword)
	Reranker            *retrieval.Reranker        // LLM-based reranker
	Hydration           *HyDE                      // Hypothetical Document Embeddings
	Compressor          *ContextCompressor         // Context compression
	ConversationManager *ConversationManager       // Multi-turn conversation support
	MultiHopRAG         *retrieval.MultiHopRAG     // Multi-hop RAG for complex questions
	AgenticRAG          *retrieval.AgenticRAG      // Agentic RAG with autonomous retrieval
	Cache               Cache                      // Query result cache
	Router              Router                     // Query router
	Metrics             observability.Metrics      // Metrics collector
	Logger              observability.Logger       // Logger
	Tracer              observability.Tracer       // Tracer
}

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

type Option func(*EngineConfig)

type QueryOptions struct {
	TopK              int
	PromptTemplate    string
	Stream            bool
	UseMultiHopRAG    bool   // Use multi-hop RAG for complex questions
	UseAgenticRAG     bool   // Use agentic RAG with autonomous retrieval
	MaxHops           int    // Maximum number of hops for multi-hop RAG
	AgentInstructions string // Instructions for agentic RAG
}

type Response struct {
	Answer  string
	Sources []core.Result
}

type RouteResult struct {
	Type   string
	Params map[string]interface{}
}

type Router interface {
	Route(ctx interface{}, question string) (RouteResult, error)
}

type Source struct {
	Type    string      // Document type/format (e.g., "text", ".pdf", ".docx")
	Path    string      // File path (if indexing a file)
	Content string      // Text content (if indexing a string)
	Reader  interface{} // Reader interface (if indexing from a reader)
}

type StreamResponse struct {
	Chunk   string
	Sources []core.Result
	Done    bool
	Error   error
}