0Pricing
AI Agents · Leçon

Construire un agent fiable pour remplir des formulaires

Une étude de cas pratique : se connecter à un portail, remplir un formulaire de plusieurs pages et vérifier l’envoi.

Construire un agent fiable pour remplir des formulaires est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Un projet réaliste

Un agent qui « remplit ce formulaire multipage ». Nous allons combiner Playwright, la planification par LLM, les nouvelles tentatives et une solution de repli par vision.

Architecture

  1. Le LLM lit les exigences des champs dans une spécification JSON
  2. Playwright ouvre le formulaire
  3. Pour chaque champ, trouvez le sélecteur et la valeur, remplissez le champ, puis validez
  4. Si un champ est difficile à localiser via le DOM, utilisez la vision comme solution de repli
  5. Envoyez le formulaire et vérifiez la réussite

Step 1: Define the Task

TASK = {
    'url': 'https://example.com/apply',
    'login': {'user': 'alice', 'pass': '...'},
    'fields': {
        'first_name': 'Alice',
        'last_name': 'Smith',
        'email': 'alice@example.com',
        'role': 'Senior Engineer'
    }
}

Step 2: Login

page.goto(TASK['url'])
if page.locator('input[name="username"]').is_visible():
    page.fill('input[name="username"]', TASK['login']['user'])
    page.fill('input[name="password"]', TASK['login']['pass'])
    page.click('button[type="submit"]')
    page.wait_for_load_state('networkidle')

Step 3: Field Filler

def fill_field(page, field_name, value):
    for selector in [
        f'input[name="{field_name}"]',
        f'input[aria-label="{field_name}"]',
        f'input[placeholder*="{field_name}"]',
        f'label:has-text("{field_name}") + input'
    ]:
        if page.locator(selector).count() > 0:
            page.fill(selector, value)
            return True
    return False

# --- demo ---
class _FakeLocator:
    def __init__(self, found):
        self._found = found
    def count(self):
        return 1 if self._found else 0

class _FakePage:
    """Only the 3rd selector (placeholder) matches, to show the fallback loop."""
    def locator(self, selector):
        return _FakeLocator(found='placeholder*=' in selector)
    def fill(self, selector, value):
        print(f'Filled via selector: {selector} -> {value!r}')

page = _FakePage()
ok = fill_field(page, 'email', 'alice@example.com')
print(f'fill_field succeeded: {ok}')

Step 4 : localisateur assisté par LLM

Si les sélecteurs standard échouent, demandez au LLM d’identifier le champ :

def ask_llm_for_selector(html, field_name):
    prompt = f'Find the input element for "{field_name}" in this HTML and return a CSS selector. HTML:\n{html[:5000]}'
    return llm.invoke(prompt).content.strip()

Step 5 : solution de repli par vision

Si même le LLM ne trouve pas de sélecteur, prenez une capture d’écran et utilisez la vision :

if not filled:
    screenshot = page.screenshot()
    coordinate = vision_llm_locate(screenshot, field_name)
    page.mouse.click(coordinate.x, coordinate.y)
    page.keyboard.type(value)

Step 6 : valider chaque étape

Après le remplissage, relisez la valeur :

actual = page.input_value(selector)
assert actual == expected_value, f'Expected {expected_value}, got {actual}'

Step 7: Submit and Verify

page.click('button[type="submit"]')
page.wait_for_load_state('networkidle')
if page.locator('text=Thank you').count() == 0:
    raise SubmissionFailed('Success page not detected')

Step 8 : logique de nouvelle tentative

Les formulaires connaissent parfois des problèmes. Réessayez avec des vérifications d’idempotence :

@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
def fill_and_submit(page, task):
    ...

Step 9 : gestion des CAPTCHA

Si le formulaire contient reCAPTCHA, utilisez un service de résolution (2Captcha, Anti-Captcha) — ou échouez proprement et demandez l’aide d’un humain.

Step 10 : journalisation et relecture

Enregistrez chaque action et chaque capture d’écran. En cas d’échec, vous pourrez relire la trace pour déboguer :

context.tracing.stop(path=f'trace-{task_id}.zip')
# View with: playwright show-trace trace-abc.zip

Considérations sur la concurrence

Pour traiter en parallèle les formulaires de nombreux utilisateurs, créez un contexte de navigateur par tâche. Limitez la concurrence afin de ne pas surcharger le site cible.

Respecter la cible

  • Ralentissez entre les actions (les humains ne tapent pas à 200 caractères par seconde)
  • Respectez robots.txt et les conditions d’utilisation
  • Utilisez des adresses IP tournantes uniquement lorsque cela est autorisé
  • Évitez les abus — le trafic d’un agent n’est pas une campagne massive de collecte

Stratégie de robustesse

Quelle est la stratégie la plus fiable pour remplir des formulaires avec un HTML imprévisible ?

Récapitulatif

Playwright + sélecteurs assistés par LLM + solution de repli par vision + validation à chaque étape + nouvelles tentatives + journaux de trace. La recette pour remplir des formulaires de manière fiable.

Questions Fréquemment Posées

La leçon « Construire un agent fiable pour remplir des formulaires » est-elle gratuite ?

Oui — le texte complet de « Construire un agent fiable pour remplir des formulaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire un agent fiable pour remplir des formulaires » ?

Une étude de cas pratique : se connecter à un portail, remplir un formulaire de plusieurs pages et vérifier l’envoi. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Construire un agent fiable pour remplir des formulaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Automatisation du navigateur avec Playwright
  2. Modèles de vision pour comprendre l’écran
  3. Modèles d’utilisation de l’ordinateur (Anthropic Computer-Use)
  4. Construire un agent fiable pour remplir des formulaires
← Retour à AI Agents