Farfalle, un clone de Perplexity

Moteur de recherche open source alimenté par l’IA (Clone de Perplexity)

Perplexity AI est un moteur de recherche qui fonctionne comme un assistant virtuel avec IA, en utilisant les serveurs de la société OpenAI.

L’application Farfalle reprend globalement les fonctionnalités de Perplexity … sauf que vous pouvez exécuter votre LLM local (llama3, gemma, mistral, phi3) ou choisir d’utiliser des modèles cloud (Groq/Llama3, OpenAI/gpt4-o).

L’intérêt d’utiliser des modèles locaux est que les sociétés OpenAI / Microsoft ne peuvent plus stocker pas vos données, vos recherches, vos prompts sur leur serveurs…

Vous avez ainsi la ‘garantie’ que votre utilisation de votre ‘moteur de recherche + AI’ ne sera pas partagée / vendue par ces sociétés commerciales à des courtiers en données personnelles ou seulement pour améliorer leur modèles.

Vous reprenez la maitrise des données de votre entreprises (et des données de vos clients …qui ne seraient pas vraiment enchantés d’apprendre que leurs informations personnelles et données sensibles servent à entrainer les LLM des sociétés OpenAI, Microsoft, Anthropic…etc.).


Démo avec lama3 sur un Macbook Pro M1 : 


💻 Version de démonstration :

farfalle.dev (Modèles en ligne uniquement)


Fonctionnalités :
  • Effectuez des recherches avec plusieurs fournisseurs de recherche (Tavily, Searxng)
  • Posez des questions en utilisant des modèles de langage locaux : Llama3, mistral, gemma, phi3
  • Posez des questions en utilisant des modèles de langage en ligne commerciaux : OpenAI/gpt4-o, OpenAI/gpt3.5-turbo, Groq/Llama3

Obtenir des clés API (facultatif) :

Installation :

1. Installez les progiciels nécessaires :
Installez les progiciels nécessaires (s’ils ne sont pas déjà installés) :

Exécutez en premier la commande suivante pour vérifier et installer les mise à jour :

sudo apt update
sudo apt upgrade
sudo apt install -y apache2 apache2-utils
sudo systemctl start apache2
sudo systemctl enable apache2
sudo iptables -I INPUT -p tcp --dport 80 -j ACCEPT 
sudo iptables -I INPUT -p tcp --dport 443 -j ACCEPT

Créez un fichier de configuration servername.conf :

sudo nano /etc/apache2/conf-available/servername.conf

Ajoutez dans le fichier /etc/apache2/conf-available/servername.conf la ligne suivante :

ServerName localhost

Enregistrez et fermez le fichier : Pour enregistrer un fichier dans l’éditeur de texte « Nano », appuyez sur les touches Ctrl + O (pour ‘Oui’) ou sur Ctrl + Y (pour ‘Yes), puis appuyez sur Entrée pour confirmer.

Pour quitter l’éditeur de texte ‘Nano’, appuyez sur les touches : Ctrl + X.

Activez ensuite ce fichier de configuration sous le serveur Apache avec la commande suivante :

sudo a2enconf servername.conf

Rechargez Apache pour que la modification prenne effet :

sudo systemctl reload apache2

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Docker Compose est un outil qui permet de configurer facilement des applications ou des services complexe composés de divers conteneurs. Pour installer Docker Compose sur votre système Ubuntu, téléchargez la version la plus récente (à partir du site officiel) et exécutez la commande suivante:

sudo curl -L « https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m) » -o /usr/local/bin/docker-compose
sudo apt-get install docker-compose-plugin

Après avoir installé Docker Compose, donnez-lui les autorisations nécessaires pour qu’elle puisse être exécutée correctement:

sudo chmod +x /usr/local/bin/docker-compose

Une fois l ‘installation terminée, vous pouvez exécuter le service Docker sur votre système en exécutant la commande :

sudo systemctl start docker
sudo systemctl enable docker

Installez Conda /miniconda :

sudo wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

Ou si vous avez un Raspberry 4 ou 5 ou un OrangePi 5, executez la commande suivante :

sudo wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh

Puis, exécutez la commande suivante :

sudo bash Miniconda3-latest-Linux-x86_64.sh

Ou si vous avez un Raspberry 4 ou 5 ou un OrangePi 5, executez la commande suivante :

sudo bash Miniconda3-latest-Linux-aarch64.sh

Installez Yarn :

sudo npm install --global yarn

Installez git :

sudo apt install git

Installez FFmpeg :

sudo apt install ffmpeg

Installez Python :

sudo apt update
sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget libbz2-dev
sudo wget https://www.python.org/ftp/python/3.11.3/Python-3.11.3.tgz
sudo tar -xf Python-3.11.3.tgz
cd Python-3.11.3
sudo ./configure --enable-optimizations
sudo make -j 12
sudo make altinstall

Si vous avez une carte graphique Nvidia Rtx, installez Cuda :

sudo su
wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_550.54.14_linux.runsudo sh cuda_12.4.0_550.54.14_linux.run

sudo apt update
sudo apt-get install nodejs
sudo apt install build-essential
sudo apt install npm


2. Cloner le dépot Git de Farfalle :
sudo git clone git@github.com:rashadphz/farfalle.git &&cd farfalle

3. Ajoutez les variables d’environnement :
sudo nano.env

Ajoutez les variables suivantes au fichier .env :

Configuration des moteurs de recherche :

Vous pouvez utiliser Tavily ou Searxng comme moteur de recherche. A cette fin vous devez compléter le fichier .env par vos clé API :

  • Tavily (Nécessite une clé API) (Remplacez ‘…’ par votre clé API)
TAVILY_API_KEY=...
SEARCH_PROVIDER=tavily
  • Searxng (Aucune clé API n’est nécessaire)
SEARCH_PROVIDER=searxng

Optionnel :

Si vous souhaitez également utiliser les services d’ AI des société OpenAI et Groq, précisez vos clés API d’OpenAI et/ou Groq dans ce fichier .env :


# Cloud Models
OPENAI_API_KEY=...
GROQ_API_KEY=...
Configuration du fichier ‘docker-compose.dev.yaml’ :

Editez le fichier de la manière suivante :

sudo nano docker-compose.dev.yaml

Remplacez la ligne de ce fichier :

- NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL:-http://localhost:8000}"

par celle-ci en modifiant « localhost » par l’adresse IP de votre serveur (par exemple : 51.234.56.34) :

- NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL:-http://51.234.56.34:8000}

4. Accédez à l’application Farfalle depuis un site internet hébergé sur votre serveur ou votre VPS
4.1. Créez un nom de domaine : farfalle.exemple.com

Si vous avez installé cette application sur un serveur VPS, vous ne pourrez pas vous connecter avec votre navigateur à l’adresse locale : http://localhost:3000 de Farfalle ou à l’adresse http://192.168.1.XX:3000 du VPS.

Il faut alors créer un accès vers cette application depuis un site internet.

Pour accéder à l’application Farfalle depuis un site internet, vous devez d’abord créer un sous-domaine : par exemple « farfalle.exemple.com » depuis votre compte client de votre gestionnaire de nom de domaine en le reliant à l’adresse IP de votre serveur via un enregistrement ‘DNS A’.

Si vous ne vous vous souvenez plus comment faire, consultez de nouveau l’étape 1 de la phase 4 de notre tutoriel pour installer Juris-Tyr.

(Rappel des étapes si vous avez acheté votre nom de domaine via OVH : «Connexion à l’ Espace client d’OVH » -> Onglet « WebCloud» -> Lien « Noms de domaines » -> « exemple.com » -> Bouton « Zone DNS » -> Bouton « Créer un nouvel enregistrement » -> Bouton «  A » -> Bouton « Suivant » -> « farfalle » -> compléter l’adresse IP de votre VPS ou de votre serveur « 51.xx.xxx.xx » -> « Bouton Suivant » -> « Bouton Valider »).


4.2. Créez un fichier Virtualhost pour le serveur Apache

Une fois votre sous-domaine crée, éditez un nouveau fichier ‘farfalle.conf » dans le dossier /etc/apache2/sites-available/ avec un éditeur de texte en ligne de commande comme Nano :

sudo nano /etc/apache2/sites-available/farfalle.conf

Copiez et collez le texte suivant dans le fichier ;
(Remplacez le texte « farfalle.exemple.com » par votre propre sous-domaine et nom de domaine) 

<IfModule mod_ssl.c>
<VirtualHost *:80>
ServerName farfalle.exemple.com
ProxyPreserveHost On
ProxyRequests Off
<Proxy *>
Order deny,allow
Allow from all
</Proxy>
ProxyPass / "http://localhost:3000/
ProxyPassReverse / "http://localhost:3000/
<Location "/">
ProxyPass ws://localhost:8000
ProxyPassReverse ws://localhost:8000
</Location>
ProxyPass / http://localhost:8000
ProxyPassReverse / http://localhost:8000
RewriteEngine on
RewriteCond %{HTTP:Upgrade} =websocket
RewriteRule /(.*) ws://localhost:8000/$1 [P]
RewriteCond %{HTTP:Upgrade} !=websocket
RewriteRule /(.*) http://localhost:8000/$1 [P]
ProxyPassReverse / http://localhost:8000
RewriteCond %{HTTP:Upgrade} =websocket
RewriteRule /(.*) ws://farfalle.exemple.com/$1 [P]
RewriteCond %{HTTP:Upgrade} !=websocket
RewriteRule /(.*) http://farfalle.exemple.com/$1 [P]
ProxyPassReverse / http://farfalle.exemple.com
### Lax CSP and will not score the best on Mozilla Observatory or other platforms alike, but won't need to be updated with version changes ###
Header always set Content-Security-Policy "default-src 'none'; base-uri 'self'; font-src 'self' data: ${public_url}; media-src 'self' blob: data: https: ${public_url}; script-src 'self' 'unsafe-inline' ${public_url}; style-src 'self' 'unsafe-inline' ${public_url}; img-src 'self' data: blob: https: ${public_url}; worker-src * blob:; frame-src 'self' https://${public_url}; connect-src 'self' wss: https: ${public_url}; form-action 'self'; frame-ancestors 'self' https://${public_url} https://my.domain https://*.my.domain; manifest-src 'self'; object-src 'self' https://${public_url}"
Header always set Permissions-Policy 'geolocation=(self "https://${public_url}"), midi=(self "https://${public_url}"), sync-xhr=(self "https://${public_url}"), microphone=(self "https://${public_url}"), camera=(self "https://${public_url}"), magnetometer=(self "https://${public_url}"), gyroscope=(self "https://${public_url}"), fullscreen=(self "https://${public_url}"), payment=(self "https://${public_url}")'
SSLHonorCipherOrder Off
### Use next two for very secure connections ###
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
### Use next two for secure connections and support more endpoints ###
#SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH:ECDHE-RSA-AES128-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA128:DHE-RSA-AES128-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES128-GCM-SHA128:ECDHE-RSA-AES128-SHA384:ECDHE-RSA-AES128-SHA128:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES128-SHA128:DHE-RSA-AES128-SHA128:DHE-RSA-AES128-SHA:DHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA384:AES128-GCM-SHA128:AES128-SHA128:AES128-SHA128:AES128-SHA:AES128-SHA:DES-CBC3-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4
#SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
### Actually proxy the traffic and really the only important part ###
AllowEncodedSlashes On
RewriteEngine On
SetEnvIf Cookie "(^|;\ *)csrftoken=([^;\ ]+)" csrftoken=$2
RequestHeader set X-CSRFToken "%{csrftoken}e"
### Proxy Websockets Section 1 (works for me) ###
RewriteCond %{HTTP:UPGRADE} ^WebSocket$ [NC]
RewriteCond %{HTTP:CONNECTION} Upgrade$ [NC]
RewriteRule ^/?(.*) "ws://${local_url}:${local_port}/$1" [P,L]
### Proxy Websockets Section 2 (untested) ###
#RewriteCond %{HTTP:UPGRADE} =websocket [NC]
#RewriteRule ^/ws/(.*) ws://${local_url}:${local_port}/ws/$1 [P,L]
### Proxy everything else ###
ProxyPass / http://${local_url}:${local_port}/ connectiontimeout=6 timeout=60
ProxyPassReverse / http://${local_url}:${local_port}/
</VirtualHost>
</IfModule>

Enregistrez et fermez le fichier.
(Pour enregistrer un fichier dans l’éditeur de texte Nano, appuyez sur les touches [Control] et [o], puis sur [Enter] pour confirmer. Pour quitter, appuyez sur [Control] et [X] ).

Activez ensuite ce nouveau fichier de configuration du serveur Apache ‘hôte virtuel’ :

sudo a2ensite farfalle.conf

Exécutez la commande suivante pour activer les modules Apache requis :

sudo a2enmod rewrite headers env dir mime setenvif ssl proxy_http proxy rewrite proxy_wstunnel

 Recharger Apache et les modules PHP :

sudo systemctl restart apache2

Démarrer le serveur Ollama :

sudo ollama serve

Téléchargez le modèles Mistral ou Llama3 :

sudo ollama pull mistral

Quittez le serveur Ollama en appuyant sur les touches [Control] et [d]


5. Exécutez Docker :

Exécutez cette commande :

sudo docker-compose -f docker-compose.dev.yaml up -d

Allez à l’adresse http://localhost:3000 pour utiliser l’app Farfalle

Pour un installation personnalisée, consultez cette page : custom-setup-instructions.md


Utilisez Farfalle comme moteur de recherche :

Pour utiliser Farfalle comme moteur de recherche par défaut, procédez comme suit :

  1. Allez dans les paramètres de votre navigateur
  2. Allez dans « Moteurs de recherche »
  3. Créez une nouvelle entrée de moteur de recherche en utilisant cette URL : http://localhost:3000/?q=%s.
  4. Ajoutez le moteur de recherche.