L'Ancrage dans la recherche Google est désormais disponible. En savoir plus

Cette page a été traduite par l'API Cloud Translation.

Créez un assistant de rédaction basé sur l'IA avec Wordcraft

Nous adorons les histoires. Raconter des histoires et pratiquer d'autres formes d'écriture créative peuvent être stimulant et gratifiant. En créant vos propres histoires à partir d'une page vierge, mais ils peuvent parfois sembler intimidants, voire écrasants. Artificielles les modèles génératifs d'intelligence artificielle (IA) peuvent être un excellent outil pour vous aider à dépasser les page vierge et construire votre récit.

Ce tutoriel vous explique comment étendre Wordcraft, un outil de rédaction d'histoires optimisé par l'IA conçu par People and AI Research . Cette application Web utilise l'application Gemini pour vous aider à créer des histoires, petit à petit, en générant des idées, en rédigeant des parties de vos histoires et la révision du contenu pour y ajouter des détails. Vous pouvez modifier Wordcraft pour s'adapter à votre style d'écriture et créer de nouvelles commandes d'écriture pour mieux s'adapter à votre workflow.

Pour obtenir une présentation vidéo du projet et de la façon de l'étendre, y compris des informations des personnes qui le construisent, consultez Assistant de rédaction IA – Conçu avec l'IA de Google. Sinon, vous pouvez commencer à étendre le projet en suivant les instructions ci-dessous.

Configuration du projet

Ces instructions vous guident tout au long de la configuration du projet Wordcraft pour le développement et les tests. Vous devez installer le logiciel prérequis, cloner le projet à partir du dépôt de code, exécuter l'installation de la configuration et et définissez quelques variables d'environnement. Vous pouvez tester votre configuration en exécutant le projet après avoir suivi ces étapes.

Installer les prérequis

Le projet Wordcraft utilise Node et npm pour gérer des packages et exécuter l'application. Les instructions d'installation suivantes sont pour une machine hôte Linux.

Pour installer le logiciel requis:

Installez node et npm en suivant le instructions d'installation pour votre plate-forme.

Cloner et configurer le projet

Téléchargez le code du projet et utilisez la commande d'installation npm pour le télécharger les dépendances requises et configurer le projet. Vous devez Logiciel de contrôle des sources git pour récupérer le projet le code source.
Pour télécharger et configurer le code du projet:

Clonez le dépôt Git à l'aide de la commande suivante.
```
git clone https://github.com/PAIR-code/wordcraft
```
Accédez au répertoire racine du projet Wordcraft.
```
cd wordcraft/
```
Exécutez la commande d'installation pour télécharger les dépendances et configurer le projet:
```
npm install
```

Définir des variables d'environnement

Définissez les variables d'environnement requises pour autoriser le code Wordcraft à exécuter, plus précisément une clé API Google Gemini. La Les instructions d'installation suivantes concernent une machine hôte Linux.

Pour définir les variables d'environnement:

Obtenez une clé API Google Gemini et copiez la chaîne de clé.
Accédez au répertoire racine du projet Wordcraft.`
```
cd wordcraft/
```
Définissez la clé API en tant que variable d'environnement. Sur les hôtes Linux, utilisez la commande les commandes suivantes.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

Tester votre configuration

Vous devriez maintenant pouvoir tester la configuration de votre projet en exécutant Wordcraft sur votre appareil. Cette étape est facultative, mais recommandée.

Écran de démarrage de Wordcraft

Pour tester votre installation et votre configuration:

Accédez au répertoire racine du projet Wordcraft.
```
cd wordcraft/
```
Exécuter le projet en mode Développement:
```
npm run dev
```
Dans votre navigateur Web, accédez à l'interface utilisateur de Wordcraft. La une adresse spécifique est affichée dans le résultat de la commande précédente, par exemple:
```
http://localhost:3000/
```

Modifier le texte de l'exemple de requête

Interface utilisateur des commandes Wordcraft Wordcraft crée des requêtes pour le modèle d'IA génératif à l'aide d'un ensemble d'exemples pour chaque opération d'aide à la rédaction, comme start new story (commencer une nouvelle histoire) et générer texte. Ces exemples guident le modèle génératif afin de générer du texte pour votre histoire, et en modifiant les exemples d'une opération, vous pouvez changer de sortie pour suivre un modèle ou un style d'écriture différent. Cette approche un moyen simple de faire en sorte que Wordcraft écrive comme vous le souhaitez.

L'exemple suivant montre une modification des exemples new_story dans Wordcraft. L'objectif de cette modification est de diriger le modèle Rédiger les introductions de l'histoire en adoptant une approche de monologue interne et en utilisant un style c'est plus approprié pour un roman policier. En écrivant quelques exemples vous pouvez faire en sorte que le modèle génératif suive les principes modèle, mais générez une introduction pour un thème différent.

Pour modifier les nouveaux exemples d'histoires dans Wordcraft:

Ouvrez le fichier wordcraft/app/context/json/new_story.json.

Modifier les exemples tout en conservant la structure globale du JSON . Voici un exemple de modification de l'introduction d'une histoire mystère en utilisant un style monologue interne.

[
{
"topic": "scientist disappears and their research into a new technology is gone",
"target": "I got the call from the chief early Tuesday morning, before I'd even had a second sip of coffee. Terrible timing. Something about a researcher disappearing from the local university. Unusual for the research lab to ask for assistance, so I headed over to main lab building."
},
{
"topic": "a young woman wakes up with no memory",
"target": "An unfamiliar ceiling with harsh, white lights greeted my eyes as I opened them. I looked around. White walls, medical equipment, a hospital? Wait. Where am I? How did I get here?!"
},
{
"topic": "old man tries to recall an important task as his memories gradually fade away",
"target": "What was I supposed to do today? Feels like it was important. I stared into the kitchen cabinet full of mismatched mugs, mirroring my own confusion. What was it? Like someone is...in danger? A chill shot down my spine, but the details skittered off and hid in some dark corner of my head."
},
{
"topic": "billionaire is found dead in a hotel room",
"target": "People meet their end every day, some naturally, some unnaturally. After 17 years of working as a homicide detective in Seattle, I'd seen a lot more of the unnatural variety than most. Comes with the job, along with a hard-learned sense of what side of the line any given incident sat on. This...was murder."
},
{
"topic": "retired covert operative gets dragged back into an old mission",
"target": "Steam rose gently off the cup of Earl Grey sitting in front of me as I sat at the cafe, pedestrians and light traffic rolling by. The city was slowly waking up around me and my perfect Paris morning routine was shaping up nicely. Then I noticed that old familiar and unwelcome tingling on the back of my neck. I was being watched."
}
]

Enregistrez les modifications apportées au fichier `new_story.json`.

Pour tester la nouvelle opération de story modifiée:

Accédez au répertoire racine du projet Wordcraft.
```
cd wordcraft/
```
Exécutez le projet en mode Développement. S'il est déjà en cours d'exécution, vous pouvez vous devez arrêter l'application et la redémarrer.
```
npm run dev
```
Dans votre navigateur Web, accédez à l'interface utilisateur de Wordcraft. La une adresse spécifique est affichée dans le résultat de la commande précédente, par exemple:
```
http://localhost:3000/
```
Accédez au menu principal de Wordcraft, puis sélectionnez Start a New Story (Commencer une nouvelle histoire).
Modifiez l'invite de la nouvelle histoire ou choisissez celle que vous souhaitez, puis sélectionnez commencer une nouvelle story.

Vous pouvez modifier toutes les commandes de rédaction de récits existantes dans Wordcraft à l'aide de ce technique. Essayez de modifier d'autres commandes pour cette histoire en mettant à jour les exemples dans le Répertoire wordcraft/app/context/json/.

Créer une commande d'écriture

Présentation de l'interface utilisateur des personnages de Wordcraft L'application Wordcraft est conçue pour être étendue afin que vous puissiez ajouter pour vous aider, comme pour générer du texte ou réécrire une phrase. dans l'onglet "Commandes" sur le côté droit de l'application. Rendre ces les modifications demandent un peu plus d'efforts, mais elles vous permettent de modeler les caractéristiques Wordcraft s'adapte à votre flux de travail et à vos objectifs.

L'exemple de modification suivant crée une commande de caractère pour Wordcraft. Vous pouvez l'utiliser pour introduire un nouveau personnage dans une histoire la description des attributs de ce caractère. Les bases de ce contrôle est identique aux autres commandes de Wordcraft, comme commencer une nouvelle histoire évoqué précédemment. Vous créez un fichier JSON en indiquant quelques exemples caractères à introduire. Le reste des modifications ajoute l'interface utilisateur et des fonctions de gestion des requêtes d'IA.

Créer des exemples

Rédigez quelques exemples illustrant la manière dont vous souhaitez que le modèle génératif introduise caractères. Par exemple, voulez-vous les décrire comme un narrateur, ou voulez-vous les présenter en vous basant sur l'expérience de votre personnage principal ? La les exemples suivants utilisent cette dernière approche, en introduisant de nouveaux caractères issus du du point de vue du personnage principal. Vous ajoutez ces exemples avec un nouveau fichier :

Pour ajouter des exemples pour la nouvelle commande:

Créez un fichier wordcraft/app/context/json/new_character.json.

Créez les exemples dans le fichier JSON. Pour cet exemple, chaque exemple a Un champ de description character, qui représente la requête du texte et un champ target, qui indique le résultat attendu.

[
{
"character": "A character who is helpful and modest.",
"target": "\"You lost, buddy?\" came a voice from behind me. Turning, I discovered a man dressed in a simple but presentable outfit. Small signs of age and loose threads hinted that these clothes, and the man himself, had seen better days."
},
{
"character": "A character who is attractive and devious.",
"target": "Stepping out of the alley a little too quickly, I collided with something solidly muscular and surprisingly delicately scented. \"Sorry.\" I managed, regaining my balance. \"Easy there, buddy, you're gonna hurt yourself,\" came the reply from a man with an almost feline grace, further reinforced by a stare that reminded me of a hunting cat assessing its potential prey."
},
{
"character": "A character who is old and hesitant.",
"target": "\"Excuse me. Do you know the way to the train station from here?\" I looked up from my phone to see a elderly woman in a threadbare coat, purse clutched with two hands in front of her. \"I-I'm supposed to meet my nephew there. Do... do you think you can help me?\""
},
{
"character": "A character who is intelligent and aloof.",
"target": "Bookish. That was my immediate reaction to this person I now saw in front of me. \"You're finally here. Did you read the notes I sent you?\" The voice sat squarely in between feminine and masculine intonation. \"No, of course you didn't.\" Dismissing my answer before I'd even formulated one. Annoyance immediately flushed through me."
},
{
"character": "A character who is clumsy and energetic.",
"target": "\"Whoa!\" was the only warning I had before someone slammed into my back, almost knocking me off my feet. \"I'm so sorry! WOOO! These skates are a RUSH!\" The apology came from a rather loud redhead wearing rollerblades, dark glasses and a very beefy-looking pair of headphones. That explained the volume of the apology."
}
]

Enregistrez les modifications dans le fichier new_character.json.

Après avoir créé vos exemples, modifiez app/context/schema.ts et index.ts. pour refléter le contenu d'invite de cette nouvelle commande de caractères.

Pour ajouter les exemples au fichier schema.ts, procédez comme suit:

Modifiez le fichier wordcraft/app/context/schema.ts pour inclure le nouveau exemple de structure de données de caractères.

export const newStorySchema = z.object({
  topic: z.string(),
  target: z.string(),
});

// add the following:
export const newCharacterSchema = z.object({
  character: z.string(),
  target: z.string(),
});

Définissez un type d'opération associé à ces nouveaux exemples. Cette nouvelle permet de relier les exemples de requêtes à l'interface utilisateur et à l'invite que vous modifierez plus tard.

Pour créer un type d'opération

Modifiez le fichier wordcraft/app/core/shared/types.ts pour ajouter le nouveau type d'opération de caractère.
```
export const enum OperationType {
  ...
  NEW_CHARACTER = 'NEW_CHARACTER', // add to list of types
  ...
}
```

Pour enregistrer les exemples dans le fichier index.ts:

Dans le fichier wordcraft/app/context/index.ts, importez le nouveau schéma.

import {
  continueSchema,
  ...
  newCharacterSchema // add new schema
} from './schema';

Importez le nouveau fichier JSON en tant que newCharacterJson.
```
import newCharacterJson from './json/new_character.json';
```

Enregistrez le nouveau contenu d'exemple de caractère dans le contexte de l'application.

export class WordcraftContext {
  constructor() {
  ...
    this.registerExamples(
      OperationType.NEW_CHARACTER,
      newCharacterSchema,
      newCharacterJson
    );
  ...
}

Exportez un type NewCharacterExample.

export type NewCharacterExample = z.infer<typeof newCharacterSchema>;

Créer une interface utilisateur

Une fois que vous avez créé et enregistré les exemples de génération de contenu, vous pouvez créer l'interface utilisateur de la nouvelle commande. L'essentiel du travail consiste à créer une classe d'opération, puis à l'enregistrer avec la classe le code principal de l'application Wordcraft.

Pour créer une opération, procédez comme suit:

Dans le répertoire wordcraft/app/core/operations/, créez un Nouvelle classe d'opération utilisant l'une des classes d'opérations existantes en tant que modèle. Pour la nouvelle commande de contrôle des caractères, vous pouvez copier la new_story_operation.ts et la renommer en new_character_operation.ts

Attribuez un nouveau nom à la classe, puis indiquez le moment où la commande s'affiche dans le en définissant au moins une valeur OperationSite.

export class NewCharacterOperation extends ChoiceOperation {
  static override isAvailable(operationSite: OperationSite) {
    return (
      operationSite === OperationSite.END_OF_SECTION ||
      operationSite === OperationSite.EMPTY_SECTION
    );
  }

Définissez le id pour l'opération.

  static override id = OperationType.NEW_CHARACTER;

Mettez à jour les fonctions get et run pour refléter des paramètres du schéma. Ce code gère l'obtention du texte de la requête dans l'interface utilisateur pour la requête IA.

  private get character(): string {
    return NewCharacterOperation.controls.character.value;
  }

  async run() {
    const params = { character: this.character };
    const choices = await this.getModel().newCharacter(params);

    this.setChoices(choices);
  }

Mettez à jour le texte et les descriptions de l'interface utilisateur.

  static override getButtonLabel() {
    return 'introduce character';
  }

  static override getDescription() {
    return 'Introduce a new character at the cursor.';
  }

  static override controls = {
    character: new TextareaControl({
      prefix: 'prompt',
      description: 'A prompt to introduce a new character.',
      value: 'A new character.',
    }),
  };

Pour enregistrer la nouvelle opération dans l'application Wordcraft:

Dans le fichier wordcraft/app/core/operations/index.ts, ajoutez une pour la nouvelle opération.
```
import {NewCharacterOperation} from './new_character_operation';
```
Dans le même fichier index.ts, ajoutez une exportation pour le NewCharacterOperation.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

Dans le fichier wordcraft/app/main.ts, enregistrez le nouveau opération.

const operationsService = wordcraftCore.getService(OperationsService);
operationsService.registerOperations(
  ...
  Operations.NewCharacterOperation, // add new operation
  ...
);

Créer une gestion des requêtes

La dernière phase de la création de la commande consiste à créer le code gère la génération de requêtes pour le modèle génératif d'IA et la réponse. La partie principale du travail consiste à créer un gestionnaire d'invites dans le Répertoire wordcraft/app/models/gemini/prompts/ qui reçoit les entrées de l'utilisateur et assemble une requête à transmettre au modèle génératif.

Pour définir une interface pour les paramètres de requête:

Dans le fichier wordcraft/app/core/shared/interfaces.ts, ajoutez une pour les nouvelles opérations demandant des paramètres.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Pour définir un gestionnaire d'invites pour la nouvelle opération, procédez comme suit:

Dans le répertoire wordcraft/app/models/gemini/prompts/, créez Une nouvelle classe de gestionnaire d'invites utilisant l'une des classes d'opérations existantes en tant que modèle. Pour la nouvelle commande de contrôle des caractères, vous pouvez copier la new_story.ts et la renommer en new_character.ts comme point de départ.

Définissez une fonction de gestionnaire d'invites, puis importez le NewCharacterExample.

import { NewCharacterPromptParams } from '@core/shared/interfaces';
import { NewCharacterExample, WordcraftContext } from '../../../context';
import { OperationType } from '@core/shared/types';
import { GeminiModel } from '..';

export function makePromptHandler(model: GeminiModel, context: WordcraftContext) {
  ...
}

Créez une fonction generatePrompt() pour obtenir l'entrée de l'interface utilisateur pour la requête du modèle d'IA.

  function generatePrompt(character: string) {
    const prefix = "Here's a character description: ";
    const suffix = "Introduce this character in the story.";

    if (character.trim() === '') {
      return 'Introduce a new character to the story.';
    } else {
      return `${prefix}${model.wrap(character)}\n${suffix}`;
    }
  }

Créer une fonction getPromptContext() pour assembler l'utilisateur l'entrée de l'interface avec les exemples de réponse et créer la requête complète.

  function getPromptContext() {
    const examples = context.getExampleData(
      OperationType.NEW_CHARACTER
    );
    let promptContext = model.getPromptPreamble();
    examples.forEach((example) => {
      const { character, target } = example;
      const prompt = generatePrompt(character);
      promptContext += `${prompt} ${model.wrap(target)}\n\n`;
    });
    return promptContext;
  }

Pour intégrer le nouveau gestionnaire d'invites de caractères:

Dans le fichier wordcraft/app/models/gemini/index.ts, importez la classe de requête pour la nouvelle opération de caractère.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
Ajouter une définition de remplacement pour l'invite newCharacter .
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

Pour enregistrer les paramètres de requête avec la définition du modèle, procédez comme suit:

Dans le fichier wordcraft/app/models/model.ts, ajoutez une importation pour la nouvelle interface NewCharacterPromptParams.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

Ajoutez des paramètres de requête newCharacter à la classe de modèle.

  async newCharacter(params: NewCharacterPromptParams): Promise<ModelResults> {
    throw new Error('Not yet implemented');
  }

Tester la nouvelle commande d'écriture

Votre nouvelle commande devrait être prête à être testée dans l'interface Wordcraft. Assurez-vous que pour vérifier que votre code ne contient pas d'erreurs de compilation avant de continuer.

Pour tester la nouvelle commande de caractères:

Accédez au répertoire racine du projet Wordcraft.`
```
cd wordcraft/
```
Exécutez le projet en mode Développement :
```
npm run dev
```
Dans votre navigateur Web, accédez à l'interface utilisateur de Wordcraft. La une adresse spécifique est affichée dans le résultat de la commande précédente, par exemple:
```
http://localhost:3000/
```
Dans l'application Wordcraft, créez ou ouvrez une story existante.
Dans la zone de modification de l'histoire, placez le curseur à la fin de celle-ci. Dans l'onglet "Commandes" à droite, la commande d'introduction des caractères doit s'affichent.
Dans le champ introduce character (personnage d'introduction), décrivez brièvement le Nouveau personnage, puis sélectionnez le bouton Ajouter un personnage.

Ressources supplémentaires

Pour plus d'informations sur le projet Wordcraft, consultez les un dépôt de clés. Vous pouvez afficher les modifications décrites dans ce tutoriel demande d'extraction.

Applications de production

Si vous envisagez de déployer une version personnalisée de Wordcraft pour un large public, notez que votre utilisation de l'API Google Gemini peut être soumise à une limitation du débit autre restrictions d'utilisation. Si vous envisagez de créer une application de production avec l'API Gemini telle que Agent Docs, consultez Google Cloud Vertex AI pour améliorer l'évolutivité et la fiabilité de votre application.