service

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

type AgentServiceConfig struct {
	BaseDir      string
	WebEnabled   bool
	SearchApiKey string
}

type CachedEmbedding struct {
	Embedding  []float32
	CreatedAt  time.Time
	AccessedAt time.Time
	UseCount   int // Pour garder trace des éléments les plus utilisés
}

type ChunkFilter struct {
	DocumentSubstring string
	ShowContent       bool
}

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

type ChunkingConfig struct {
	ChunkSize        int    // Target size of each chunk in characters
	ChunkOverlap     int    // Number of characters to overlap between chunks
	IncludeMetadata  bool   // Whether to include metadata in chunk content
	ChunkingStrategy string // Strategy to use: "fixed", "semantic", "hybrid", "hierarchical"
}

type ChunkingEvaluationMetrics struct {
	// Basic metrics
	TotalChunks      int     // Total number of chunks produced
	AverageChunkSize float64 // Average chunk size in characters
	SizeStdDeviation float64 // Standard deviation of chunk sizes
	MaxChunkSize     int     // Size of the largest chunk
	MinChunkSize     int     // Size of the smallest chunk

	// Coherence metrics
	ChunksWithSplitSentences  int     // Number of chunks that split sentences
	ChunksWithSplitParagraphs int     // Number of chunks that split paragraphs
	SemanticCoherenceScore    float64 // Estimated semantic coherence score

	// Performance metrics
	ProcessingTimeMs int64 // Processing time in ms

	// Distribution metrics
	ContentCoverage float64 // % of original content covered by chunks
	RedundancyRate  float64 // Redundancy rate due to overlap

	// Strategy info
	Strategy     string // Strategy used
	ChunkSize    int    // Configured chunk size
	ChunkOverlap int    // Configured overlap
}

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

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

type DocumentLoaderOptions struct {
	ExcludeDirs      []string
	ExcludeExts      []string
	ProcessExts      []string
	ChunkSize        int
	ChunkOverlap     int
	ChunkingStrategy string  // Chunking strategy: "fixed", "semantic", "hybrid", "hierarchical"
	APIProfileName   string  // Name of the API profile to use
	EnableReranker   bool    // Whether to enable reranking - now true by default
	RerankerModel    string  // Model to use for reranking
	RerankerWeight   float64 // Weight for reranker scores (0-1)
}

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

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

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

type RagService interface {
	CreateRagWithOptions(modelName, ragName, folderPath string, options DocumentLoaderOptions) error
	GetRagChunks(ragName string, filter ChunkFilter) ([]*domain.DocumentChunk, error)
	LoadRag(ragName string) (*domain.RagSystem, error)
	Query(rag *domain.RagSystem, query string, contextSize int) (string, error)
	AddDocsWithOptions(ragName string, folderPath string, options DocumentLoaderOptions) error
	UpdateModel(ragName string, newModel string) error
	UpdateRag(rag *domain.RagSystem) error
	UpdateRerankerModel(ragName string, model string) error
	ListAllRags() ([]string, error)
	GetOllamaClient() *client.OllamaClient
	// Directory watching methods
	SetupDirectoryWatching(ragName string, dirPath string, watchInterval int, options DocumentLoaderOptions) error
	DisableDirectoryWatching(ragName string) error
	CheckWatchedDirectory(ragName string) (int, error)
	// Web watching methods
	SetupWebWatching(ragName string, websiteURL string, watchInterval int, options domain.WebWatchOptions) error
	DisableWebWatching(ragName string) error
	CheckWatchedWebsite(ragName string) (int, error)
}

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

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

type RankedResult struct {
	Chunk         *domain.DocumentChunk
	VectorScore   float64
	RerankerScore float64
	FinalScore    float64
}

type RerankerOptions struct {
	// TopK is the number of documents to return after reranking
	TopK int

	// InitialK is the number of documents to retrieve from the initial search
	// before reranking (should be >= TopK)
	InitialK int

	// RerankerModel is the model to use for reranking
	// If empty, will default to the same model used for embedding
	RerankerModel string

	// ScoreThreshold is the minimum relevance score (0-1) for a document to be included
	// Documents with scores below this threshold will be filtered out
	ScoreThreshold float64

	// RerankerWeight defines the weight of the reranker score vs vector similarity
	// 0.0 = use only vector similarity, 1.0 = use only reranker scores
	RerankerWeight float64

	// AdaptiveFiltering when true, uses content relevance to select chunks
	// rather than a fixed top-k approach
	AdaptiveFiltering bool
}

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

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