blomios/Tradarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add download features to llm models

Browse Source
This commit is contained in:
Blomios
2026-04-20 22:50:16 +02:00
parent 351dd3b608
commit 6274b4a0b8
11 changed files with 910 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
backend/internal/ai/pipeline.go
View File

@ -50,28 +50,36 @@ func (p *Pipeline) BuildProvider(name, apiKey, endpoint string) (Provider, error
return NewProvider(name, apiKey, model, endpoint)
}
// buildProviderForRole resolves and builds the AI provider for a given task role.
func (p *Pipeline) buildProviderForRole(role string) (Provider, *models.AIProvider, error) {
cfg, model, err := p.repo.GetRoleProvider(role)
if err != nil {
return nil, nil, fmt.Errorf("get provider for role %s: %w", role, err)
}
if cfg == nil {
return nil, nil, fmt.Errorf("no AI provider configured for role %s", role)
}
apiKey := ""
if cfg.APIKeyEncrypted != "" {
apiKey, err = p.enc.Decrypt(cfg.APIKeyEncrypted)
if err != nil {
return nil, nil, fmt.Errorf("decrypt API key for role %s: %w", role, err)
}
}
provider, err := NewProvider(cfg.Name, apiKey, model, cfg.Endpoint)
if err != nil {
return nil, nil, fmt.Errorf("build provider for role %s: %w", role, err)
}
return provider, cfg, nil
}
func (p *Pipeline) GenerateForUser(ctx context.Context, userID string) (*models.Summary, error) {
p.generating.Store(true)
defer p.generating.Store(false)
providerCfg, err := p.repo.GetActiveAIProvider()
if err != nil {
return nil, fmt.Errorf("get active provider: %w", err)
}
if providerCfg == nil {
return nil, fmt.Errorf("no active AI provider configured")
}
apiKey := ""
if providerCfg.APIKeyEncrypted != "" {
apiKey, err = p.enc.Decrypt(providerCfg.APIKeyEncrypted)
if err != nil {
return nil, fmt.Errorf("decrypt API key: %w", err)
}
}
provider, err := NewProvider(providerCfg.Name, apiKey, providerCfg.Model, providerCfg.Endpoint)
provider, providerCfg, err := p.buildProviderForRole("summary")
if err != nil {
return nil, fmt.Errorf("build provider: %w", err)
return nil, err
}
assets, err := p.repo.GetUserAssets(userID)
@ -105,9 +113,13 @@ func (p *Pipeline) GenerateForUser(ctx context.Context, userID string) (*models.
// Passe 1 : filtrage par pertinence — seulement si nettement plus d'articles que le max
if len(articles) > maxArticles*2 {
filterProvider, _, filterErr := p.buildProviderForRole("filter")
if filterErr != nil {
filterProvider = provider // fallback to summary provider
}
fmt.Printf("[pipeline] Passe 1 — filtrage : %d articles → sélection des %d plus pertinents…\n", len(articles), maxArticles)
t1 := time.Now()
articles = p.filterByRelevance(ctx, provider, symbols, articles, maxArticles)
articles = p.filterByRelevance(ctx, filterProvider, symbols, articles, maxArticles)
fmt.Printf("[pipeline] Passe 1 — terminée en %s : %d articles retenus\n", time.Since(t1).Round(time.Second), len(articles))
} else if len(articles) > maxArticles {
articles = articles[:maxArticles]
@ -135,49 +147,84 @@ func (p *Pipeline) GenerateForUser(ctx context.Context, userID string) (*models.
return p.repo.CreateSummary(userID, summary, &providerCfg.ID)
}
// filterByRelevance demande à l'IA de sélectionner les articles les plus pertinents
// en ne lui envoyant que les titres (prompt très court = rapide).
// filterByRelevance splits articles into batches and asks the AI to select relevant
// ones from each batch. Results are pooled then truncated to max.
func (p *Pipeline) filterByRelevance(ctx context.Context, provider Provider, symbols []string, articles []models.Article, max int) []models.Article {
prompt := buildFilterPrompt(symbols, articles, max)
// Passe 1 : pas de think, contexte réduit (titres seulement = prompt court)
response, err := provider.Summarize(ctx, prompt, GenOptions{Think: false, NumCtx: 8192})
if err != nil {
fmt.Printf("[pipeline] Passe 1 — échec (%v), repli sur troncature\n", err)
return articles[:max]
batchSizeStr, _ := p.repo.GetSetting("filter_batch_size")
batchSize, _ := strconv.Atoi(batchSizeStr)
if batchSize <= 0 {
batchSize = 20
}
indices := parseIndexArray(response, len(articles))
var selected []models.Article
numBatches := (len(articles) + batchSize - 1) / batchSize
for b := 0; b < numBatches; b++ {
start := b * batchSize
end := start + batchSize
if end > len(articles) {
end = len(articles)
}
batch := articles[start:end]
fmt.Printf("[pipeline] Passe 1 — batch %d/%d (%d articles)…\n", b+1, numBatches, len(batch))
t := time.Now()
chosen := p.filterBatch(ctx, provider, symbols, batch)
fmt.Printf("[pipeline] Passe 1 — batch %d/%d terminé en %s : %d retenus\n", b+1, numBatches, time.Since(t).Round(time.Second), len(chosen))
selected = append(selected, chosen...)
// Stop early if we have plenty of candidates
if len(selected) >= max*2 {
fmt.Printf("[pipeline] Passe 1 — suffisamment de candidats (%d), arrêt anticipé\n", len(selected))
break
}
}
if len(selected) <= max {
return selected
}
return selected[:max]
}
// filterBatch asks the AI to return all relevant articles from a single batch.
func (p *Pipeline) filterBatch(ctx context.Context, provider Provider, symbols []string, batch []models.Article) []models.Article {
prompt := buildFilterBatchPrompt(symbols, batch)
response, err := provider.Summarize(ctx, prompt, GenOptions{Think: false, NumCtx: 4096})
if err != nil {
fmt.Printf("[pipeline] filterBatch — échec (%v), conservation du batch entier\n", err)
return batch
}
indices := parseIndexArray(response, len(batch))
if len(indices) == 0 {
fmt.Printf("[pipeline] Passe 1 — réponse non parseable, repli sur troncature\n")
return articles[:max]
return nil
}
filtered := make([]models.Article, 0, len(indices))
for _, i := range indices {
filtered = append(filtered, articles[i])
if len(filtered) >= max {
break
}
filtered = append(filtered, batch[i])
}
return filtered
}
func buildFilterPrompt(symbols []string, articles []models.Article, max int) string {
func buildFilterBatchPrompt(symbols []string, batch []models.Article) string {
var sb strings.Builder
sb.WriteString("Tu es un assistant de trading financier. ")
sb.WriteString(fmt.Sprintf("Parmi les %d articles ci-dessous, sélectionne les %d plus pertinents pour un trader actif.\n", len(articles), max))
sb.WriteString("Tu es un assistant de trading financier.\n")
sb.WriteString(fmt.Sprintf("Parmi les %d articles ci-dessous, sélectionne TOUS ceux pertinents pour un trader actif.\n", len(batch)))
if len(symbols) > 0 {
sb.WriteString("Actifs surveillés (priorité haute) : ")
sb.WriteString("Actifs prioritaires : ")
sb.WriteString(strings.Join(symbols, ", "))
sb.WriteString("\n")
}
sb.WriteString(fmt.Sprintf("\nRéponds UNIQUEMENT avec un tableau JSON des indices sélectionnés (base 0), exemple : [0, 3, 7, 12]\n"))
sb.WriteString("\nRéponds UNIQUEMENT avec un tableau JSON des indices retenus (base 0), exemple : [0, 2, 5]\n")
sb.WriteString("Si aucun article n'est pertinent, réponds : []\n")
sb.WriteString("N'ajoute aucun texte avant ou après le tableau JSON.\n\n")
sb.WriteString("Articles :\n")
for i, a := range articles {
for i, a := range batch {
sb.WriteString(fmt.Sprintf("[%d] %s (%s)\n", i, a.Title, a.SourceName))
}
@ -243,25 +290,9 @@ func (p *Pipeline) GenerateReportAsync(reportID, excerpt, question string, mgr *
}
func (p *Pipeline) callProviderForReport(ctx context.Context, excerpt, question string) (string, error) {
providerCfg, err := p.repo.GetActiveAIProvider()
provider, _, err := p.buildProviderForRole("report")
if err != nil {
return "", fmt.Errorf("get active provider: %w", err)
}
if providerCfg == nil {
return "", fmt.Errorf("no active AI provider configured")
}
apiKey := ""
if providerCfg.APIKeyEncrypted != "" {
apiKey, err = p.enc.Decrypt(providerCfg.APIKeyEncrypted)
if err != nil {
return "", fmt.Errorf("decrypt API key: %w", err)
}
}
provider, err := NewProvider(providerCfg.Name, apiKey, providerCfg.Model, providerCfg.Endpoint)
if err != nil {
return "", fmt.Errorf("build provider: %w", err)
return "", err
}
prompt := fmt.Sprintf(