Le jour où j’ai brisé mon propre chatbot IA essayant de le rendre «plus intelligent» | par définicode | Jul, 2025

Cela a commencé avec un simple objectif. Je voulais juste un chatbot IA qui pouvait parler comme moi, répondre aux questions des clients et traiter les requêtes d’intégration pour mon projet. Un assistant léger construit sur les API d’Openai.

L’image de zoom sera affichée

Mais quelque part en cours de route, je suis devenu gourmand. J’ai ajouté des intégres. Puis j’ai ajouté la voix. Puis entrée de vision multimodale. Puis mémoire. Puis des arbres de décision. Ensuite, tout a cessé de fonctionner.

C’est l’histoire complète de la façon dont j’ai construit un chatbot utile, je l’ai détruit avec des fonctionnalités «cool», et je l’ai finalement ramené à la vie avec un design plus maigre.

Décomposons-le.

Ma première version du bot était propre. Il a utilisé GPT-4oa répondu aux questions de base en utilisant une courte invite et a renvoyé les résultats directement dans une boîte de chat Web. Voici à quel point il avait l’air minimal:

import openai
openai.api_key = "your-api-key"
def chat_with_bot(user_input):
messages = (
{"role": "system", "content": "You are a helpful assistant that speaks like Shahzaib."},
{"role": "user", "content": user_input}
)
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages
)
return response.choices(0).message('content')
print(chat_with_bot("Hey, how do I onboard a new client?"))

Cela a parfaitement fonctionné. Rien d’extraordinaire, mais rapide et précis.

Ensuite, j’ai pensé – ne serait-ce pas génial s’il se souvenait des conversations passées?

J’ai intégré Pinecone pour stocker des incorporations vectorielles d’historique de chat, je les ai récupérées en utilisant la recherche de similitude et je les ai injectées dans l’invite. Voici comment je l’ai fait:

import pinecone
from sentence_transformers import SentenceTransformer
pinecone.init(api_key="your-pinecone-key", environment="gcp-starter")
index = pinecone.Index("chat-memory")
model = SentenceTransformer('all-MiniLM-L6-v2')
def store_memory(user_input):
embedding = model.encode((user_input))(0).tolist()
index.upsert(((f"msg-{hash(user_input)}", embedding, {"text": user_input})))
def retrieve_context(query):
query_vec = model.encode((query))(0).tolist()
result = index.query(vector=query_vec, top_k=3, include_metadata=True)
return "n".join((match('metadata')('text') for match in result('matches')))

J’ai fusionné les messages récupérés dans l’invite du système. Cela fonctionnait bien, mais l’invite allait plus longtemps et les réponses étaient plus lentes.

J’ai lu sur l’entrée de la vision de GPT-4O et j’ai immédiatement pensé – pourquoi ne pas permettre aux utilisateurs de télécharger des captures d’écran des bogues et d’obtenir des suggestions?

J’ai construit une petite interface qui a permis des téléchargements d’image. Ensuite, j’ai ajouté la logique comme ceci:

def chat_with_image(image_path, question):
with open(image_path, "rb") as f:
image_bytes = f.read()
messages = (
{
"role": "user",
"content": (
{"type": "text", "text": question},
{"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + base64.b64encode(image_bytes).decode()}}
)
}
)
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=messages
)
return response.choices(0).message('content')

Cela a fonctionné… mais uniquement pour des captures d’écran propres. La performance a été frappée ou manquée.

Pourtant, j’ai continué à pousser.

Ensuite, j’ai ajouté Whisper pour l’entrée vocale. Ensuite, la lecture audio en temps réel à l’aide de WebSockets. L’interface utilisateur était laggy. Les erreurs ont commencé à apparaître. Le chatbot a commencé à halluciner – mauvais.

À un moment donné, cela a suggéré de supprimer une base de données entière juste pour «résoudre la confusion de l’utilisateur». C’est là que je savais que j’étais allé trop loin.

Voici la partie chuchotée qui a commencé le gâchis:

import openai
import sounddevice as sd
import numpy as np
import tempfile
def record_audio(duration=5):
fs = 44100
recording = sd.rec(int(duration * fs), samplerate=fs, channels=1)
sd.wait()
return recording.flatten()
def transcribe_audio(audio):
with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
sd.write(temp_file.name, audio, 44100)
audio_file = open(temp_file.name, "rb")
transcript = openai.Audio.transcribe("whisper-1", audio_file)
return transcript('text')

Toute cette complexité pour un bot qui répondait à l’origine à des questions d’intégration.

Voici ce qui n’a pas fonctionné:

• Les invites étaient gonflées avec trop de contexte
• La transcription audio a introduit la latence
• Les entrées d’image ont rendu le débogage impossible
• Mémoire vectorielle a tiré des messages non pertinents
• Le chatbot a gelé sur de grandes entrées

Le résultat: un chatbot qui a pris 8 secondes pour répondre, s’est souvent confus, et parfois n’a pas répondu du tout.

J’ai tout retiré aux bases.

Cette fois, je l’ai fait différemment.

• Pas de mémoire vectorielle. J’ai utilisé du threading basé sur les mots clés.
• Aucune vision. Juste lié les téléchargements pour une revue manuelle.
• Entrée vocale? Bascule facultative. Par défaut est le texte.
• Une invite. Pas de chaînage.

Ce n’était pas flashy, mais c’est travaillé. Le LLM avait moins de bruit, a donné de meilleures réponses, et je pouvais enfin lui faire confiance.

• Plus de fonctionnalités ≠, mieux UX
• L’ingénierie rapide simple peut surpasser les systèmes de mémoire compliqués
• GPT-4O est puissant, mais seulement si vous lui donnez un contexte clair et pertinent
• Laissez votre assistant IA être stupide dans certaines régions si cela le rend plus intelligent dans d’autres

Je pensais que je faisais un chatbot plus intelligent en y jetant tout. En réalité, je l’ai rendu plus lent, plus maladroit et peu fiable. La meilleure IA est invisible – elle aide sans vous en remarquer.

Maintenant, le chatbot est à nouveau maigre. Et enfin, les utilisateurs l’adorent.