Intégrer Ollama dans une séquence d'automatisation

Pourquoi un LLM local ?

Intégrer un LLM dans une automatisation ouvre des possibilités inatteignables avec du code classique : analyser le sens d'un message d'erreur, classer un document selon son contenu, rédiger un compte-rendu à partir de données structurées. Mais les LLMs cloud (OpenAI, Claude, Gemini) posent un problème fondamental en environnement professionnel : les données sortent du réseau interne.

Ollama résout ce problème en faisant tourner des modèles de qualité (Llama 3, Mistral, Qwen) entièrement en local. AutomationSequence V8 intègre un connecteur Ollama natif — le LLM devient une action comme les autres dans la séquence JSON.

Dans un hôpital ou une entreprise HDS, aucune donnée patient ou confidentielle ne doit transiter par un API cloud. Ollama + AutomationSequence V8 : le LLM reste sur votre réseau.

Installation et configuration

# 1. Installer Ollama (Windows/Linux/macOS)
# https://ollama.ai — installeur natif

# 2. Télécharger un modèle
ollama pull llama3:8b        # 4.7 GB — bon équilibre vitesse/qualité
ollama pull mistral:7b       # 4.1 GB — rapide, bon en français
ollama pull qwen2.5:14b      # 9 GB — excellent en analyse

# 3. Configurer dans AutomationSequence
# Outils → Préférences → IA/LLM
# ollama_url: http://localhost:11434
# default_model: llama3:8b

Choisir le bon modèle

Modèle	Taille	Vitesse	Usage recommandé
Llama 3 8B	4.7 GB	Rapide	Analyse, résumé, classification
Mistral 7B	4.1 GB	Très rapide	Français, traitement de texte
Qwen 2.5 14B	9 GB	Moyen	Analyse complexe, code, JSON
Llama 3 70B	40 GB	Lent (GPU requis)	Tâches complexes, haute qualité
nomic-embed-text	274 MB	Très rapide	Embeddings, classification sémantique

Actions LLM disponibles

• llm_query — envoie un prompt, récupère la réponse dans une variable.
• llm_analyze — analyse un texte long avec chunking automatique si trop grand pour le contexte.
• llm_classify — classifie un texte parmi des catégories définies, retourne la catégorie et un score de confiance.
• llm_extract_json — extrait des données structurées d'un texte libre au format JSON.
• llm_generate — génère un document (rapport, email, compte-rendu) à partir d'un template et de données.
• llm_embed — calcule l'embedding vectoriel d'un texte (pour similarité sémantique).

Cas d'usage : analyse de logs

[
  {
    "type": "file_read",
    "path": "logs/app_{{date_today}}.log",
    "output_var": "log_content"
  },
  {
    "type": "llm_analyze",
    "model": "llama3:8b",
    "prompt": "Analyse ce log applicatif. Identifie les erreurs critiques, leur fréquence et leur cause probable. Réponds en JSON avec les clés: erreurs_critiques, cause_probable, actions_recommandees. Log:\n{{log_content}}",
    "temperature": 0.1,
    "output_format": "json",
    "output_var": "analyse_logs"
  },
  {
    "type": "condition",
    "if": "len({{analyse_logs.erreurs_critiques}}) > 0",
    "then": "send_alert"
  }
]

Cas d'usage : classification de documents

{
  "type": "llm_classify",
  "model": "mistral:7b",
  "text": "{{document_content}}",
  "categories": [
    "facture",
    "bon_commande",
    "contrat",
    "courrier",
    "autre"
  ],
  "output_var": "doc_category",
  "confidence_var": "doc_confidence"
}
# {{doc_category}} → "facture"
# {{doc_confidence}} → 0.94

Cas d'usage : génération de rapports

{
  "type": "llm_generate",
  "model": "qwen2.5:14b",
  "template": "Rédige un rapport d'activité mensuel pour le service {{service}} basé sur ces données : {{stats_json}}. Format : résumé exécutif (3 phrases), points forts, points d'amélioration, conclusion.",
  "temperature": 0.4,
  "output_var": "rapport_texte"
}

Limites et bonnes pratiques

• Taille du contexte — Llama 3 8B : 8 000 tokens (~6 000 mots). Pour des logs volumineux, utiliser llm_analyze qui découpe automatiquement.
• Température basse pour l'analyse — 0.1 à 0.2 pour les tâches analytiques, 0.4 à 0.7 pour la génération de texte.
• Toujours valider le JSON — même avec output_format: "json", ajouter une action json_validate après llm_extract_json.
• Timeout — configurer un timeout (30–120s selon le modèle) pour éviter les blocages en cas de surcharge GPU.

Conclusion

Ollama + AutomationSequence V8 transforme un LLM local en composant d'automatisation comme un autre. Le LLM reçoit des variables de séquence, produit des variables consommables par les actions suivantes, et son exécution est loguée dans le journal HMAC. La combinaison est particulièrement puissante pour l'analyse de logs, la classification de documents et la génération de rapports en environnement off-line.