Contexte#

Je suis tombé sur une vidéo assez intéressante sur Fabric qui permet d’optimiser l’utilisation de l’IA grâce à une meilleures organisation du coeur de l’IA: les prompts. Merci NetworkChuck pour cette découverte !

J’ai donc décidé d’essayer et de l’installer sur mon ordinateur pour voir comment ça fonctionne.

Ma curiosité est débordante… Surtout avec des outils qui aide au quotidien.

Quoi?#

Fabric, C’est quoi?#

Fabric, c’est quoi ? Fabric, c’est un outil, une interface qui a été créée par un homme assez fantastique: Daniel Miessler, qui a la base travail dans la cybersécurité, et qui aide à résoudre un problème, le problème d’intégration de l’IA dans notre quotidien, dans notre travail.

Pour faire simple, il permet de créer des prompts très pointus, mais à la fois faciles à mettre en place sous format de fichier Markdown, et le système va s’interfacer pour utiliser ces fichiers-là et donner du contexte et un prompt à une IA de son choix pour qu’elle puisse délivrer les instructions.

Infomaniak#

Ensuite, pourquoi j’ai choisi Infomaniak ? Tout simplement pour le côté souveraineté numérique, engagement durable. C’est une société qui a toujours montré patte blanche en termes social, local, etc. C’est suisse, ça suit toutes les recommandations européennes, et c’est pas américain. Et ça, ça me va bien.

C’est aussi mon choix pour l’achat de mon nom de domaine. Et tout récemment, j’ai découvert qu’ils avaient un outil IA qui était open source hébergé chez eux et chiffré de bout en bout pour éviter que mes données partent n’importe où.

Comment?#

RTFM (Read the fucking manual) ou bien LLDP (Lit la documentation put***)

Installation#

Alors, je fais l’installation sur une WSL 2 Ubuntu sur un ordinateur Windows.

Fabric#

Documentation d’installation

  1. J’installe Golang sudo apt install golang
  2. J’installe Fabric go install github.com/danielmiessler/fabric@latest
  3. Je rajoute dans le fichier .bashrc ce contenu:
# Golang environment variables
export GOROOT=/usr/local/go
export GOPATH=$HOME/go

# Update PATH to include GOPATH and GOROOT binaries
export PATH=$GOPATH/bin:$GOROOT/bin:$HOME/.local/bin:$PATH

Cela sert à pouvoir utiliser la commande fabric.

  1. Je rafraichis mon bashrc avec la commande source ~/.bashrc
  2. Je vérifie que ça fonctionne fabric -h
Usage:
  fabric [OPTIONS]

Application Options:
  -p, --pattern=                    Choose a pattern from the available patterns

  -S, --setup                       Run setup for all reconfigurable parts of fabric

Help Options:
  -h, --help                        Show this help message

Je vous laisse la joie d’explorer l’aide et le github pour comprendre les commandes.

Yt-dlp#

C’est l’utilitaire qui va servir à récuperer les vidéos et transcription pour l’analyse IA. Github Installation du binaire

  1. J’installe le binaire curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/bin/yt-dlp
  2. Je le rend executable chmod a+rx /usr/bin/yt-dlp
  3. Je vérifie que ça fonctionne
maxime@Desktop-Maxime:~$ yt-dlp --version
2025.06.25

Xclip#

Utilitaire pour copier et coller dans le CLI Linux.

sudo apt update && sudo apt install xclip -y

API Keys#

Je fais exprès de faire les API Keys d’abord car tu en as besoin lors de la configuration de Fabric. Il y a deux API que tu as besoin celle de ton fournisseur d’IA (Infomaniak pour moi) et l’API de youtube ! Documentation Infomaniak Documentation Google Il faudra suivre correctement ses documentations pour vous procurer vos API keys.

Configuration#

Le fun commence ! Les moments de debug intense car je ne lis jamais correctement la doc… Ps: c’est faux.

Le but ici est de configurer les différents outils pour que tout fonctionne correctement.

  1. Laisser le setup fabric --setup
maxime@Desktop-Maxime:~$ fabric --setup

Available plugins (please configure all required plugins)::

AI Vendors [at least one, required]

        [1]     AIML
        [2]     Anthropic
        [3]     Azure
        [4]     Cerebras
        [5]     DeepSeek
        [6]     Exolab
        [7]     Gemini
        [8]     GrokAI
        [9]     Groq
        [10]    Langdock
        [11]    LiteLLM
        [12]    LM Studio
        [13]    Mistral
        [14]    Ollama (configured)
        [15]    OpenAI (configured)
        [16]    OpenRouter
        [17]    Perplexity
        [18]    SiliconCloud

Tools

        [19]    Default AI Vendor and Model [required] (configured)
        [20]    Jina AI Service - to grab a webpage as clean, LLM-friendly text (configured)
        [21]    Language - Default AI Vendor Output Language (configured)
        [22]    Patterns - Downloads patterns [required] (configured)
        [23]    Strategies - Downloads Prompting Strategies (like chain of thought) [required] (configured)
        [24]    YouTube - to grab video transcripts (via yt-dlp) and comments/metadata (via YouTube API) (configured)

[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
  1. On va configurer notre fournisseur d’IA ici le choix 15 pour moi !
[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
15

[OpenAI]

Enter your OpenAI API KEY (leave empty for 'Votre_Clé_API' or type 'reset' to remove the value):


Enter your OpenAI API BASE URL (leave empty for 'https://api.infomaniak.com/1/ai/{product_id}/openai' or type 'reset' to remove the value):

Attention ici l’URL dépend de votre situation !

  1. Je configure mon LLM par défaut
[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
19
Ollama Get "http://localhost:11434/api/tags": dial tcp 127.0.0.1:11434: connect: connection refused

Available models:

OpenAI

        [1]     bge_multilingual_gemma2
        [2]     flux
        [3]     granite
        [4]     llama3
        [5]     mini_lm_l12_v2
        [6]     mistral24b
        [7]     photomaker
        [8]     reasoning
        [9]     whisper
        [10]    whisperV2

[Default]

Enter the index the name of your default model (leave empty for 'mistral24b' or type 'reset' to remove the value):

Je n’utilise pas Ollama, mais il revient systématiquement donc je n’y touche pas.

  1. Je configure la langue en fr-FR
[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
21

[Language]

Enter your default output language (for example: zh_CN) (leave empty for 'fr_FR' or type 'reset' to remove the value):
  1. LE PLUS IMPORTANT, je télécharge les “patterns”= les prompts
[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
22

[Patterns Loader]

Enter the default Git repository URL for the patterns (leave empty for 'https://github.com/danielmiessler/fabric.git' or type 'reset' to remove the value):


Enter the default folder in the Git repository where patterns are stored (leave empty for 'patterns' or type 'reset' to remove the value):

Downloading patterns and Populating /home/maxime/.config/fabric/patterns...
  1. Je configure les stratégies aussi (tout laisser par défaut)
  2. Je rentre l’API key de Youtube
[Plugin Number] Enter the number of the plugin to setup (leave empty to skip):
24

[YouTube]

Enter your YouTube API KEY (leave empty for 'Votre_API_KEY' or type 'reset' to remove the value):

Tu penses que c’est fini? Et bien pas tout à fait…

  1. Il faut maintenant créer les alias pour que tout ce beau monde fonctionne au poil.

# Golang environment variables
export GOROOT=/usr/local/go
export GOPATH=$HOME/go

# Update PATH to include GOPATH and GOROOT binaries
export PATH=$GOPATH/bin:$GOROOT/bin:$HOME/.local/bin:$PATH

# Bash completion for fabric CLI
_fabric() {
  local cur prev words cword
  _get_comp_words_by_ref -n : cur prev words cword

  # Define all possible options/flags
  local opts="--pattern -p --variable -v --context -C --session --attachment -a --setup -S --temperature -t --topp -T --stream -s --presencepenalty -P --raw -r --frequencypenalty -F --listpatterns -l --listmodels -L --listcontexts -x --listsessions -X --updatepatterns -U --copy -c --model -m --modelContextLength --output -o --output-session --latest -n --changeDefaultModel -d --youtube -y --playlist --transcript --transcript-with-timestamps --comments --metadata --language -g --scrape_url -u --scrape_question -q --seed -e --wipecontext -w --wipesession -W --printcontext --printsession --readability --input-has-vars --dry-run --serve --serveOllama --address --api-key --config --version --listextensions --addextension --rmextension --strategy --liststrategies --listvendors --shell-complete-list --help -h"

  # Helper function for dynamic completions
  _fabric_get_list() {
    fabric "$1" --shell-complete-list 2>/dev/null
  }

  # Handle completions based on the previous word
  case "${prev}" in
  -p | --pattern)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listpatterns)" -- "${cur}"))
    return 0
    ;;
  -C | --context)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listcontexts)" -- "${cur}"))
    return 0
    ;;
  --session)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listsessions)" -- "${cur}"))
    return 0
    ;;
  -m | --model)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listmodels)" -- "${cur}"))
    return 0
    ;;
  -w | --wipecontext)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listcontexts)" -- "${cur}"))
    return 0
    ;;
  -W | --wipesession)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listsessions)" -- "${cur}"))
    return 0
    ;;
  --printcontext)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listcontexts)" -- "${cur}"))
    return 0
    ;;
  --printsession)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listsessions)" -- "${cur}"))
    return 0
    ;;
  --rmextension)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --listextensions)" -- "${cur}"))
    return 0
    ;;
  --strategy)
    COMPREPLY=($(compgen -W "$(_fabric_get_list --liststrategies)" -- "${cur}"))
    return 0
    ;;
  # Options requiring file/directory paths
  -a | --attachment | -o | --output | --config | --addextension)
    _filedir
    return 0
    ;;
  # Options requiring simple arguments (no specific completion logic here)
  -v | --variable | -t | --temperature | -T | --topp | -P | --presencepenalty | -F | --frequencypenalty | --modelContextLength | -n | --latest | -y | --youtube | -g | --language | -u | --scrape_url | -q | --scrape_question | -e | --seed | --address | --api-key)
    # No specific completion suggestions, user types the value
    return 0
    ;;
  esac

  # If the current word starts with '-', suggest options
  if  "${cur}" == -* ; then
    COMPREPLY=($(compgen -W "${opts}" -- "${cur}"))
    return 0
  fi

  # Default: complete files/directories if no other rule matches
  # _filedir
  # Or provide no completions if it's not an option or argument following a known flag
  COMPREPLY=()

}

complete -F _fabric fabric

# Loop through all files in the ~/.config/fabric/patterns directory
for pattern_file in $HOME/.config/fabric/patterns/*; do
    # Get the base name of the file (i.e., remove the directory path)
    pattern_name=$(basename "$pattern_file")

    # Create an alias in the form: alias pattern_name="fabric --pattern pattern_name"
    alias_command="alias $pattern_name='fabric --pattern $pattern_name'"

    # Evaluate the alias command to add it to the current shell
    eval "$alias_command"
done

yt() {
    if [ "$#" -eq 0 ] || [ "$#" -gt 2 ]; then
        echo "Usage: yt [-t | --timestamps] youtube-link"
        echo "Use the '-t' flag to get the transcript with timestamps."
        return 1
    fi

    transcript_flag="--transcript"
    if [ "$1" = "-t" ] || [ "$1" = "--timestamps" ]; then
        transcript_flag="--transcript-with-timestamps"
        shift
    fi
    local video_link="$1"
    fabric -y "$video_link" $transcript_flag
}

#Copy and paste with xclip

alias pbpaste='xclip -selection clipboard -o'
alias pbcopy='xclip -selection clipboard'

J’ai combiné la documentation de Fabric afin de faciliter le rajout.

  1. Ne pas oublier un petit source ~/.bashrc pour être sûr d’avoir accès aux alias.

Maintenance#

Pour faire les mise à jour :

  • yt-dlp -U
  • go install github.com/danielmiessler/fabric@latest

Conclusion#

Ce projet n’était pas prévu. J’ai été fasciné par le potentiel de Fabric et de pouvoir le coupler avec de l’IA Open-Source et sécurisé par un Data-Center de qualité. Il n’y avait pas de documentation francophone pour ce projet. Et bien maintenant il y en aura une !