L’année 2022 a marqué l’arrivée de l’intelligence artificielle dans notre quotidien, et chacun s’est plus ou moins intéressé à cette nouvelle technologie, oscillant entre fantasmes et réalités. De manière naturelle, de nombreux outils ont émergé sur internet pour aider les développeurs à exploiter au mieux cette avancée et à construire des applications innovantes autour d’elle. Aujourd’hui, nous allons nous pencher tout particulièrement sur “langchain”, une boîte à outils complète permettant de tirer pleinement parti des “LLMs” (Large Language Model).
Nous allons mettre à profit les talents des générations de chatGPT pour suggérer les meilleurs noms de domaines disponibles aux entrepreneurs intéressés. L’idée consiste donc à créer une application qui prendra en entrée une thématique donnée ainsi qu’un nombre souhaité de suggestions, et qui fournira en sortie une liste de noms de domaines. Ce qui rend notre application unique, c’est qu’elle ne proposera que des noms de domaines disponibles à la réservation.
Quelles sont les étapes nécessaires pour construire cette application?
Pour réaliser cette application nous avons besoin de 3 outils:
- langchain qui va s’occuper des interactions avec chatGPT
- un model de génération de texte de la famille de chatGPT3
- Whois qui est le module python qui va nous permettre de vérifier si le nom de domaine est disponible à l’achat.
Voici les étapes que nous allons suivre pour utiliser ces outils:
- À l’aide d’une requête bien formulée, nous demanderons à ChatGPT de générer une liste de noms de domaine en fonction de la thématique choisie.
- Ensuite, nous lui demanderons de formater correctement ces noms de domaine et de nous renvoyer une liste compatible avec les listes en Python.
- Dans un troisième temps, nous allons parcourir la liste obtenue et pour chaque nom de domaine, nous utiliserons le module Python “whois” pour vérifier s’il est disponible ou non.
Chaque fois que nous trouvons un nom de domaine disponible, nous l’ajouterons à une liste appelée “résultat” et nous répéterons l’opération jusqu’à ce que “résultat” contienne le nombre de suggestions demandées.
De l’art de discuter avec l’IA
La réussite de notre projet repose entièrement sur notre capacité à communiquer avec le model de generation de texte. La façon la plus courante de discuter avec un LLM est de lui fournir ce qu’on apelle un prompt. Un prompt est un ensemble d’instrucions plus ou moins précises qui va dire au model ce qu’on attend de lui. Il existe plusieurs techniques d’écriture de prompt. Langchain fournit un outil qui permet d’écrire les prompts de la manière la plus efficace, il s’agit des template de prompt. Nous allons nous servir de cet outil et comme nous voulons quelquechose de précis nous allons créer notre propre classe de template de prompt comme ceci:
## backend/domainGeneratorTemplate.py
from langchain.prompts import StringPromptTemplate
from langchain.output_parsers import CommaSeparatedListOutputParser
from pydantic import BaseModel, validator
output_parser = CommaSeparatedListOutputParser()
format_instructions = output_parser.get_format_instructions()
class DomainGeneratorPromptTemplate(StringPromptTemplate, BaseModel):
"""A custom prompt template that takes theme and number of domain as input, and formats the prompt template to provide a domain name list."""
@validator("input_variables")
def validate_input_variables(cls, v):
"""Validate that the input variables are correct."""
variable_list = ["theme", "number", "exclude_list"]
for variable in variable_list:
if variable not in v:
raise ValueError(f" {variable} must be in the input_variables.")
return v
def format(self, **kwargs) -> str:
prompt = f"""
As a marketing expert, your primary objective is to identify a selection of optimal domain names that align seamlessly with a given theme.
return only the domains names list, remove all trailing spaces.
the suggested domain names should not be part of the exclude list.
The domain name must be in the format : domain_name.extension.
theme:{kwargs["theme"]}
number:{kwargs["number"]}
exclude list:{kwargs["exclude_list"]}
following is an example:
theme : artificial intelligence
number: 5
exclude list : []
result for this example is : ['AIInnovators.com', 'SmartTechAI.com', 'IntelliMind.com', 'FutureAIHub.com', 'CognitiveTechLab.com']
n{format_instructions}
"""
return prompt
def _prompt_type(self):
return "domain-generator"
Veuillez noter que dans la variable “prompt”, nous spécifions explicitement au modèle le rôle qu’il doit incarner, celui d’un expert en marketing dont la mission est de suggérer les meilleurs noms de domaines. Les variables “theme”, “number” et __”exclude_list”__ seront injectées ultérieurement dans le modèle. Il en aura besoin pour générer les noms de domaines. Par ailleurs, remarquez que nous fournissons un exemple, ce qui est conseillé pour renforcer le prompt et contrôler le résultat.
Enfin, nous précisons également le format de sortie souhaité. Dans notre cas, nous avons besoin d’une liste et pour accomplir cette tâche, nous utilisons la classe CommaSeparatedListOutputParser. Cette dernière est instanciée dans __”format_instruction”__, qui sera intégrée au prompt.
Comment n’afficher que les noms de domaines disponibles?
Ce qui rend notre application interessante est sa capacité à ne fournir que les noms de domaine disponibles à l’utilisateur. Nous allons nous attaquer à cette fonctionnalité en écrivant la fonction suggest_domain comme suit:
## backend/domain_chain.py
from backend.template.domainGeneratorTemplate import DomainGeneratorPromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.output_parsers import CommaSeparatedListOutputParser
from backend.utils import domainIsAvailable
output_parser = CommaSeparatedListOutputParser()
format_instructions = output_parser.get_format_instructions()
prompt = DomainGeneratorPromptTemplate(
input_variables=["theme", "number", "exclude_list"],
partial_variables={"format_instructions": format_instructions},
)
def suggest_domain(
theme: str, number: int, openai_api_key: str, exclude_list: list = []
) -> list:
llm = OpenAI(temperature=0.9, openai_api_key=openai_api_key)
DOMAIN_GENERATOR = LLMChain(llm=llm, prompt=prompt)
output_parser = CommaSeparatedListOutputParser()
result = []
exclude_list = []
while len(result) < number:
output = DOMAIN_GENERATOR.run(
theme=theme, number=number, exclude_list=exclude_list
)
for domain in output_parser.parse(output):
if domainIsAvailable(domain=domain.lower()):
result.append(domain.lower())
else:
exclude_list.append(domain.lower())
return result
Il s’agit d’une boucle qui ajoute un nom de domaine à notre liste finale chaque fois qu’il est disponible à l’achat et tant que nous n’avons pas atteint le nombre maximum de suggestions demandées. La function domainIsAvailable est d’une simplicité déconcertante;
# backend/utils.py
import whois
def domainIsAvailable(domain: str):
try:
whois.whois(domain)
except:
return True
else:
return False
Elle va tout simplement déclencher une erreur si le domaine est disponible. On va donc renvoyer True si le domaine est disponible et False sinon.
Nous avons réussi en quelques lignes de codes à rassembler les outils dont nous avons besoin pour faire tourner notre application. Il faut maintenant les mettre ensemble pour obtenir notre application.
La partie visible de l’iceberg
Afin de faciliter l’interaction avec notre application, nous allons mettre en place un formulaire public qui permettra de recueillir les informations initiales et de renvoyer le résultat souhaité. Pour ce faire, nous allons utiliser Streamlit, un outil très pratique pour créer des interfaces web facilement. Streamlit offre une combinaison parfaite entre la simplicité du langage Python, son accessibilité et sa robustesse, ce qui en fait un choix idéal pour notre projet. Grâce à cette approche conviviale, tout le monde pourra aisément utiliser notre application et en tirer le meilleur parti.
# main.py
from backend.chains.domain_chain import suggest_domain
import streamlit as st
def display_domains(domains: list):
st.write("Domain name that you can use:")
for domain in domains:
st.markdown(f"- {domain}")
# Main function
def main():
# Title and description
st.set_page_config(page_title="Domain Name Finder")
st.image(
image="assets/images/alice_robot.png",
width=200,
use_column_width=True,
clamp=True,
)
st.title("Top-notch Domain Name Finder")
openai_api_key = "YOUR_API_KEY"
# Theme input
theme = st.text_input(
"Enter a thematic", placeholder="thematic wich you want a domain name for"
)
# Number input
number = st.number_input(
"Please specify the desired number of domain name suggestions you would like to receive.",
value=5,
max_value=10,
)
button = st.button(label="Generate")
if button:
with st.spinner("Generating domain names ..."):
if not openai_api_key.startswith("sk-"):
st.warning("Please enter your OpenAI API key!", icon="⚠")
if not theme:
st.warning("Please enter a theme!", icon="⚠")
if openai_api_key.startswith("sk-") and theme:
domains = suggest_domain(
theme=theme, number=number, openai_api_key=openai_api_key
)
display_domains(domains=domains)
main()
Après avoir installé Streamlit vous pouvez copier coller le code ci dessus dans un fichier main.py et lancer localement votre application en faisant streamlit run main.py
Résultats et perspectives
Notre application est enfin fonctionnelle, voici à quoi elle ressemble:
<iframe
src=”https://domain-finder.streamlit.app/?embed=true“
height=”800″
width=”100%”
Nous l’avons réduite à sa plus simple expression. Libre à vous de l’améliorer. Par exemple, vous pouvez rajouter la possibilité de filtrer les noms de domaines par extension. De plus, vous avez la possibilité d’ajouter un lien direct vers un hébergeur pour acheter le nom de domaine. Les possibilités offertes par cette application sont nombreuses. Envisagez les possibilités qu’une intelligence artificielle performante pourrait vous offrir.
