Grounding with Google Search ya está disponible. Más información

Se usó la API de Cloud Translation para traducir esta página.

Compila un asistente de escritura con IA con Wordcraft

Nos encantan las historias. Contar historias y hacer otras formas de escritura creativa ser desafiante y gratificante. Construir tus propias historias a partir de una página en blanco sin embargo, puede parecer abrumador e incluso abrumador en ocasiones. Artificial los modelos generativos de inteligencia artificial (IA) pueden ser una gran herramienta para ayudarte a superar el una página en blanco y cree su narrativa.

En este instructivo, se muestra cómo extender Wordcraft, una herramienta de escritura de historias potenciada por IA y creada por el grupo People and AI Research de Google equipo. Esta aplicación web usa Gemini API para ayudarte a crear historias, poco a poco, generando ideas, escribiendo partes de tus historias y revisa el contenido para agregar más detalles. Puedes modificar Wordcraft para que coincidan mejor con tu estilo de escritura y crear nuevos controles de escritura para respaldar mejor tu flujo de trabajo.

Para ver una descripción general en video del proyecto y cómo extenderlo, incluidas las estadísticas de la gente que lo construye, échale un vistazo Asistente de escritura con IA: Compila con la IA de Google. De lo contrario, puedes seguir las instrucciones para extender el proyecto a continuación.

Configura el proyecto

Estas instrucciones te guiarán a través de la configuración del proyecto Wordcraft para desarrollo y pruebas. Debes instalar el software de requisito previo, clonar el proyecto desde el repositorio de código, ejecutar la instalación de la configuración y debe establecer algunas variables de entorno. Para probar tu configuración, ejecuta el proyecto después de completar estos pasos.

Instala los requisitos previos

El proyecto Wordcraft usa Node y npm para administrar paquetes y ejecutar la aplicación. Las siguientes instrucciones de instalación son para una máquina anfitrión de Linux.

Para instalar el software requerido, sigue estos pasos:

Instala node y npm siguiendo la instrucciones de instalación para tu plataforma.

Clona y configura el proyecto

Descarga el código del proyecto y usa el comando de instalación npm para descargarlo las dependencias necesarias y configurar el proyecto. Necesitas Software de control de fuente git para recuperar el proyecto código fuente.
Para descargar y configurar el código del proyecto, haz lo siguiente:

Clona el repositorio de Git con el siguiente comando.
```
git clone https://github.com/PAIR-code/wordcraft
```
Navega al directorio raíz del proyecto Wordcraft.
```
cd wordcraft/
```
Ejecuta el comando de instalación para descargar dependencias y configurar el proyecto:
```
npm install
```

Configure las variables de entorno

Establece las variables de entorno necesarias para permitir el código de Wordcraft proyecto para ejecutar, específicamente una clave de API de Google Gemini. El Las siguientes instrucciones de instalación son para una máquina anfitrión de Linux.

Para configurar las variables de entorno, sigue estos pasos:

Obtén una clave de API de Google Gemini y copia la cadena de la clave.
Navega al directorio raíz del proyecto Wordcraft.
```
cd wordcraft/
```
Configura la clave de API como una variable de entorno. En los hosts Linux, usa el siguientes comandos.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

Pruebe su configuración

Ahora deberías poder probar la configuración de tu proyecto ejecutando Wordcraft en tu dispositivo. Este paso es opcional, pero se recomienda hacerlo.

Pantalla de inicio de Wordcraft

Para probar la instalación y configuración, haz lo siguiente:

Navega al directorio raíz del proyecto Wordcraft.
```
cd wordcraft/
```
Cómo ejecutar el proyecto en modo de desarrollo:
```
npm run dev
```
En tu navegador web, ve a la interfaz de usuario de Wordcraft. El se muestra una dirección específica en el resultado del comando anterior, por ejemplo:
```
http://localhost:3000/
```

Modifica el texto de ejemplo de la instrucción

Interfaz de usuario de comandos de Wordcraft Wordcraft crea instrucciones para el modelo generativo de IA a partir de un conjunto de ejemplos para cada operación de asistencia con la escritura, como iniciar una historia nueva y generar text. Los ejemplos guían al modelo generativo para generar texto para tu historia y, si modificas los ejemplos de una operación, puedes cambiar la que el resultado siga un patrón o un estilo de escritura diferente. Este enfoque es un sencilla de hacer que Wordcraft escriba como quieras.

En el siguiente ejemplo, se muestra una modificación de los ejemplos de new_story en Wordcraft. El objetivo de esta modificación es dirigir el modelo generativo de IA a escribir las introducciones a la historia con un enfoque de monólogo interno y usar un estilo que es más apropiado para una novela de misterio. Escribiendo algunos ejemplos de esto tipo de introducción a una historia, puedes hacer que el modelo generativo siga la pero genera una introducción para un tema diferente.

Para modificar los ejemplos de historias nuevas en Wordcraft, haz lo siguiente:

Abre el archivo wordcraft/app/context/json/new_story.json.

Modifica los ejemplos mientras mantienes la estructura general del JSON . Este es un ejemplo de modificación para una introducción a una historia de misterio con un estilo de monólogo interno.

[
{
"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."
}
]

Guarda los cambios en el archivo `new_story.json`.

Para probar la operación de historia nueva modificada, haz lo siguiente:

Navega al directorio raíz del proyecto Wordcraft.
```
cd wordcraft/
```
Ejecutar el proyecto en modo de desarrollo Si ya se está ejecutando, puedes debes detener la app y reiniciarla.
```
npm run dev
```
En tu navegador web, ve a la interfaz de usuario de Wordcraft. El se muestra una dirección específica en el resultado del comando anterior, por ejemplo:
```
http://localhost:3000/
```
Navega al menú principal de Wordcraft y selecciona Start a New Story.
Actualiza la instrucción de la historia nueva o cámbiala según lo que quieras y, luego, selecciona comenzar una historia nueva.

Puedes modificar todos los controles de escritura de historias existentes en Wordcraft con esta técnica. Intentando cambiar otros controles de historias actualizando los ejemplos en el wordcraft/app/context/json/.

Crear nuevo control de escritura

Interfaz de usuario de introducción de personajes de Wordcraft La app de Wordcraft se diseñó para extenderse, de modo que puedas agregar texto nuevo controles para ayudarte, que son similares a generar texto o Reescribir oración de la pestaña Controles a la derecha de la aplicación. Hacer estas requieren un poco más de esfuerzo, pero te permiten modelar las características de Wordcraft que se adapta a tu flujo de trabajo y a tus objetivos

La siguiente modificación de ejemplo crea un nuevo control de caracteres para Wordcraft. Puedes usarlo para presentar un nuevo personaje a una historia con una descripción de los atributos de ese carácter. La base de este control es igual a otros controles de Wordcraft, como el control de comenzar una historia nueva. que analizamos antes. Creas un archivo JSON con algunos ejemplos de cómo quieres caracteres que se presentarán. El resto de los cambios agregan la interfaz de usuario y Funciones de administración de instrucciones de IA.

Crear ejemplos

Escribe algunos ejemplos de cómo quieres que el modelo generativo presente caracteres. Por ejemplo, quieres describirlos como un narrador o ¿quieres presentarlos a través de la experiencia del personaje principal? El Los siguientes ejemplos usan el último enfoque, que introduce nuevos caracteres del el punto de vista del personaje principal. Debes agregar estos ejemplos con un nuevo archivo JSON archivo:

Para agregar ejemplos para el control nuevo, haz lo siguiente:

Crea un archivo wordcraft/app/context/json/new_character.json.

Crea los ejemplos en el archivo JSON. Para este ejemplo, cada ejemplo tiene un campo de descripción character, que representa el mensaje texto y un campo target, que muestra el resultado esperado.

[
{
"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."
}
]

Guarda los cambios en el archivo new_character.json.

Después de crear tus ejemplos, modifica app/context/schema.ts y index.ts. para reflejar el contenido del mensaje de este nuevo control de caracteres.

Para agregar los ejemplos al archivo schema.ts, haz lo siguiente:

Modifica el archivo wordcraft/app/context/schema.ts para incluir el nuevo de la estructura de datos de ejemplo.

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(),
});

Define un tipo de operación que esté asociado con estos ejemplos nuevos. Esta nueva tipo ayuda a conectar los ejemplos de instrucciones a la interfaz de usuario y a la instrucción compilar código, que modificarás en pasos posteriores.

Para crear un nuevo tipo de operación

Modifica el archivo wordcraft/app/core/shared/types.ts para agregar el nuevo el tipo de operación de caracteres.
```
export const enum OperationType {
  ...
  NEW_CHARACTER = 'NEW_CHARACTER', // add to list of types
  ...
}
```

Para registrar los ejemplos en el archivo index.ts, haz lo siguiente:

En el archivo wordcraft/app/context/index.ts, importa el esquema nuevo.

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

Importa el archivo JSON nuevo como newCharacterJson.

import newCharacterJson from './json/new_character.json';

Registra el nuevo contenido de ejemplo de caracteres en el contexto de la aplicación.

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

Exporta un tipo NewCharacterExample.

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

Compila la interfaz de usuario

Una vez que hayas creado y registrado los ejemplos de generación de contenido, puedes crear la interfaz de usuario para el nuevo control. La mayor parte del trabajo es crear una nueva clase de operación y, luego, registrar esa clase con el el código principal de la aplicación Wordcraft.

Para crear una nueva operación, sigue estos pasos:

En el directorio wordcraft/app/core/operations/, crea un nueva clase de operación usando una de las clases de operaciones existentes como una plantilla. Para el nuevo control de caracteres, puedes hacer una copia del Clase new_story_operation.ts y cámbiale el nombre a new_character_operation.ts

Dale un nuevo nombre a la clase y especifica cuándo aparece el control en la de usuario definiendo al menos un valor OperationSite.

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

Establece el id para la operación.

  static override id = OperationType.NEW_CHARACTER;

Actualiza las funciones get y run para reflejar el de los parámetros del esquema. Este código controla la obtención del texto del mensaje de la interfaz de usuario para usarlo en la instrucción de la 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);
  }

Actualiza el texto y las descripciones de la interfaz de usuario.

  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.',
    }),
  };

Para registrar la nueva operación en la aplicación Wordcraft, haz lo siguiente:

En el archivo wordcraft/app/core/operations/index.ts, agrega importar para la nueva operación.
```
import {NewCharacterOperation} from './new_character_operation';
```
En el mismo archivo index.ts, agrega una exportación para el Clase NewCharacterOperation.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

En el archivo wordcraft/app/main.ts, registra el nuevo una sola operación.

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

Crea el manejo de instrucciones

Como la fase final de la creación del nuevo control, creas el código que se encarga de generar instrucciones para el modelo generativo de IA y de la respuesta. La parte principal es compilar un controlador de instrucciones en la Directorio wordcraft/app/models/gemini/prompts/ que recibe entradas del usuario y crea una instrucción para pasar al modelo generativo.

Si quieres definir una interfaz para los parámetros de instrucciones, haz lo siguiente:

En el archivo wordcraft/app/core/shared/interfaces.ts, agrega para los parámetros de solicitud de operaciones nuevas.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Para definir un controlador de instrucciones para la nueva operación, haz lo siguiente:

En el directorio wordcraft/app/models/gemini/prompts/, crea una nueva clase de controlador de instrucciones usando una de las clases de operaciones existentes como plantilla. Para el nuevo control de caracteres, puedes hacer una copia del Clase new_story.ts y cámbiale el nombre a new_character.ts como punto de partida.

Define una función del controlador de instrucciones y, luego, importa Clase 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) {
  ...
}

Compila una función generatePrompt() para obtener la entrada de la interfaz de usuario para la instrucción del modelo de 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}`;
    }
  }

Crea una función getPromptContext() para ensamblar el usuario de interfaz con las respuestas de ejemplo y compilar la instrucción completa.

  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;
  }

Para integrar el nuevo controlador de mensajes de caracteres, haz lo siguiente:

En el archivo wordcraft/app/models/gemini/index.ts, importa el de instrucciones para la nueva operación de caracteres.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
Agrega una definición de anulación para la instrucción newCharacter controlador.
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

Para registrar los parámetros de las instrucciones con la definición del modelo, haz lo siguiente:

En el archivo wordcraft/app/models/model.ts, agrega una importación de la nueva interfaz de NewCharacterPromptParams.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

Agrega los parámetros de instrucciones newCharacter a la clase del modelo.

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

Prueba el nuevo control de escritura

Tu nuevo control debería estar listo para probarlo en la interfaz de Wordcraft. Asegúrate de que para verificar que tu código no tenga errores de compilación antes de continuar.

Para probar el nuevo control de caracteres, haz lo siguiente:

Navega al directorio raíz del proyecto Wordcraft.
```
cd wordcraft/
```
Ejecuta el proyecto en modo de desarrollo:
```
npm run dev
```
En tu navegador web, ve a la interfaz de usuario de Wordcraft. El se muestra una dirección específica en el resultado del comando anterior, por ejemplo:
```
http://localhost:3000/
```
En la aplicación Wordcraft, crea una historia nueva o abre una existente.
En el área de edición de la historia, mueve el cursor hasta el final. En La pestaña Controles de la derecha, el control de carácter de presentación debería para que aparezca la opción.
En el campo introducir personaje, escribe una breve descripción del y selecciona el botón de introducir personaje.

Recursos adicionales

Para obtener más información sobre el proyecto Wordcraft, consulta el código Cloud Storage. Puedes ver los cambios descritos en este instructivo solicitud de extracción.

Aplicaciones de producción

Si planeas implementar una versión personalizada de Wordcraft para un público numeroso, ten en cuenta que tu uso de la API de Gemini de Google puede estar sujeto al límite de frecuencia y otro restricciones de uso. Si estás considerando compilar una aplicación de producción con la API de Gemini, como Agente de Documentos, consulta Vertex AI de Google Cloud y servicios para aumentar la escalabilidad y confiabilidad de tu app.