Participe da competição de desenvolvedores da API Gemini. Saiba mais

Esta página foi traduzida pela API Cloud Translation.

Crie um assistente de escrita com IA com o Wordcraft

Adoramos histórias. Contar histórias e fazer outras formas de escrita criativa pode ser desafiador e gratificante. No entanto, criar suas próprias histórias com base em uma página em branco pode parecer assustador e até mesmo esmagador às vezes. Os modelos generativos de inteligência artificial (IA) podem ser uma ótima ferramenta para ajudar você a passar da página em branco e criar sua narrativa.

Neste tutorial, mostramos como ampliar o Wordcraft, uma ferramenta de escrita de histórias com tecnologia de IA criada pela equipe de pesquisa de pessoas e IA do Google. Esse aplicativo da Web usa a API Gemini para ajudar você a criar histórias, bit a bit, gerando ideias, escrevendo partes delas e revisando o conteúdo para adicionar mais detalhes. Você pode modificar o Wordcraft para combinar mais com seu estilo de escrita e criar novos controles de escrita para melhor apoiar o fluxo de trabalho.

Para ter uma visão geral em vídeo do projeto e saber como estendê-lo, incluindo insights das pessoas que o criaram, confira Assistente de escrita de IA: crie com IA do Google. Caso contrário, comece a estender o projeto seguindo as instruções abaixo.

Configuração do projeto

Estas instruções ajudam você a configurar o projeto do Wordcraft para desenvolvimento e teste. Você precisa instalar o software de pré-requisito, clonar o projeto do repositório de código, executar a instalação da configuração e definir algumas variáveis de ambiente. Execute o projeto depois de concluir essas etapas para testar sua configuração.

Instale os pré-requisitos

O projeto Wordcraft usa Node e npm para gerenciar pacotes e executar o aplicativo. As instruções de instalação a seguir são para uma máquina host Linux.

Para instalar o software necessário:

Instale node e npm seguindo as instruções de instalação da sua plataforma.

Clonar e configurar o projeto

Faça o download do código do projeto e use o comando de instalação npm para fazer o download das dependências necessárias e configurar o projeto. Você precisa do software de controle de origem git para recuperar o código-fonte do projeto.
Para fazer o download e configurar o código do projeto:

Clone o repositório git usando o comando a seguir.
```
git clone https://github.com/PAIR-code/wordcraft
```
Navegue até o diretório raiz do projeto do Wordcraft.
```
cd wordcraft/
```
Execute o comando de instalação para fazer o download de dependências e configurar o projeto:
```
npm install
```

Defina as variáveis de ambiente

Defina as variáveis de ambiente necessárias para permitir a execução do projeto de código do Wordcraft, especificamente uma chave de API do Google Gemini. As instruções de instalação a seguir são para uma máquina host Linux.

Para definir as variáveis de ambiente:

Gere uma chave de API do Google Gemini e copie a string da chave.
Navegue até o diretório raiz do projeto do Wordcraft.`
```
cd wordcraft/
```
Defina a chave de API como uma variável de ambiente. Nos hosts do Linux, use os comandos abaixo.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

Testar sua configuração

Agora você pode testar a configuração do projeto executando o Wordcraft no seu dispositivo. Esta etapa é opcional, mas recomendada.

Tela inicial do Wordcraft

Para testar a instalação, siga estas etapas:

Navegue até o diretório raiz do projeto do Wordcraft.
```
cd wordcraft/
```
Como executar o projeto por ele no modo de desenvolvimento:
```
npm run dev
```
Em um navegador da Web, acesse a interface do usuário do Wordcraft. O endereço específico é mostrado na saída do comando anterior, por exemplo:
```
http://localhost:3000/
```

Modificar o texto de exemplo do comando

Interface do usuário de comandos do Wordcraft O Wordcraft cria comandos para o modelo generativo de IA usando um conjunto de exemplos para cada operação de assistência de escrita, como os comandos iniciar nova história e gerar texto. Os exemplos orientam o modelo generativo na geração de texto para sua história e, ao modificar os exemplos de uma operação, é possível alterar a saída para seguir um padrão ou estilo de escrita diferente. Essa abordagem é uma maneira simples de fazer o Wordcraft escrever do jeito que você quiser.

O exemplo a seguir mostra uma modificação dos exemplos de new_story no Wordcraft. O objetivo dessa modificação é direcionar o modelo generativo de IA a escrever introduções de histórias usando uma abordagem de monólogo interno e usar um estilo mais apropriado para um romance de mistério. Ao escrever alguns exemplos desse tipo de introdução à história, é possível fazer com que o modelo generativo siga o padrão geral, mas gerar uma introdução para um tema diferente.

Para modificar os novos exemplos de história no Wordcraft:

Abra o arquivo wordcraft/app/context/json/new_story.json.

Modifique os exemplos mantendo a estrutura geral do arquivo JSON. Veja um exemplo de modificação para a introdução de uma história de mistério usando um 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."
}
]

Salve as mudanças no arquivo "new_story.json".

Para testar a operação da nova story modificada:

Navegue até o diretório raiz do projeto do Wordcraft.
```
cd wordcraft/
```
Execute o projeto no modo de desenvolvimento. Se ele já estiver em execução, talvez seja necessário interromper e reiniciar o app.
```
npm run dev
```
Em um navegador da Web, acesse a interface do usuário do Wordcraft. O endereço específico é mostrado na saída do comando anterior, por exemplo:
```
http://localhost:3000/
```
Navegue até o menu principal do Wordcraft e selecione Iniciar uma nova história.
Atualize o comando da nova história ou altere-o para o que você quiser e selecione Iniciar nova história.

É possível modificar todos os controles de escrita de história atuais no Wordcraft usando essa técnica. Tente mudar outros controles de story atualizando os exemplos no diretório wordcraft/app/context/json/.

Criar controle de escrita

Wordcraft apresenta interface de usuário de personagens O app Wordcraft foi projetado para ser estendido para que você possa adicionar novos controles de escrita para ajudar, assim como os botões gerar texto ou reescrever frase na guia "Controles" no lado direito do app. Fazer essas modificações é um pouco mais trabalhoso, mas permite que você ajuste os recursos do Wordcraft de acordo com o fluxo de trabalho e as metas.

O exemplo de modificação a seguir cria um novo controle de caracteres para o Wordcraft. Você pode usar esse recurso para apresentar um novo personagem a uma história, com uma descrição dos atributos dele. A base desse controle é a mesma de outros controles do Wordcraft, como o controle iniciar nova história discutido anteriormente. Você cria um arquivo JSON com alguns exemplos de como quer apresentar os caracteres. O restante das mudanças inclui a interface do usuário e as funções de gerenciamento de comandos de IA.

Criar exemplos

Escreva alguns exemplos de como você quer que o modelo generativo introduza caracteres. Por exemplo, você quer descrevê-los como um narrador ou apresentá-los pela experiência do seu personagem principal? Os exemplos a seguir usam essa abordagem, introduzindo novos personagens do ponto de vista do personagem principal. Adicione estes exemplos com um novo arquivo JSON:

Para adicionar exemplos para o novo controle, faça o seguinte:

Crie um arquivo wordcraft/app/context/json/new_character.json.

Crie os exemplos no arquivo JSON. Neste exemplo, cada um tem um campo de descrição character, que representa o texto da solicitação, e um campo target, que mostra a saída esperada.

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

Salve as mudanças no arquivo new_character.json.

Depois de criar os exemplos, modifique os arquivos app/context/schema.ts e index.ts para refletir o conteúdo da solicitação do novo controle de caracteres.

Para adicionar os exemplos ao arquivo schema.ts:

Modifique o arquivo wordcraft/app/context/schema.ts para incluir a nova estrutura de dados de exemplo de caracteres.

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

Defina um tipo de operação associado a esses novos exemplos. Esse novo tipo ajuda a conectar os exemplos de prompt à interface do usuário e ao código de criação do prompt, que será modificado nas etapas posteriores.

Para criar um novo tipo de operação

Modifique o arquivo wordcraft/app/core/shared/types.ts para adicionar o novo tipo de operação de caractere.
```
export const enum OperationType {
  ...
  NEW_CHARACTER = 'NEW_CHARACTER', // add to list of types
  ...
}
```

Para registrar os exemplos no arquivo index.ts:

No arquivo wordcraft/app/context/index.ts, importe o novo esquema.

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

Importe o novo arquivo JSON como newCharacterJson.

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

Registre o novo conteúdo de exemplo de caractere no contexto do aplicativo.

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

Exporte um tipo NewCharacterExample.

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

Criar a interface do usuário

Depois de criar e registrar os exemplos de geração de conteúdo, você poderá criar a interface do usuário para o novo controle. A maior parte do trabalho para essa fase é criar uma nova classe de operação e registrá-la com o código principal do aplicativo Wordcraft.

Para criar uma operação:

No diretório wordcraft/app/core/operations/, crie uma nova classe de operação usando uma das classes de operações existentes como modelo. Para o novo controle de caracteres, você pode fazer uma cópia da classe new_story_operation.ts e renomeá-la como new_character_operation.ts.

Dê um novo nome à classe e especifique quando o controle será exibido na interface do usuário definindo pelo menos um valor OperationSite.

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

Defina o id da operação.

  static override id = OperationType.NEW_CHARACTER;

Atualize as funções get e run para refletir os valores dos parâmetros do esquema. Esse código processa o recebimento do texto da solicitação da interface do usuário para uso no comando da 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);
  }

Atualize o texto e as descrições da interface do usuário.

  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 a nova operação no aplicativo Wordcraft:

No arquivo wordcraft/app/core/operations/index.ts, adicione uma importação para a nova operação.
```
import {NewCharacterOperation} from './new_character_operation';
```
No mesmo arquivo index.ts, adicione uma exportação para a classe NewCharacterOperation.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

No arquivo wordcraft/app/main.ts, registre a nova operação.

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

Criar o gerenciamento de comandos

Como fase final da criação do novo controle, você cria o código que processa a geração de solicitações para o modelo generativo de IA e processa a resposta. A parte principal do trabalho é criar um gerenciador de comandos no diretório wordcraft/app/models/gemini/prompts/, que recebe entradas da interface do usuário e monta um comando para ser transmitido ao modelo generativo.

Para definir uma interface para os parâmetros do prompt:

No arquivo wordcraft/app/core/shared/interfaces.ts, adicione uma interface para os novos parâmetros de solicitação de operações.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Para definir um gerenciador de prompts para a nova operação:

No diretório wordcraft/app/models/gemini/prompts/, crie uma nova classe de gerenciador de comandos usando uma das classes de operações como modelo. Para o novo controle de caracteres, você pode fazer uma cópia da classe new_story.ts e renomeá-la para new_character.ts como ponto de partida.

Defina uma função de gerenciador de comandos e importe a classe 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) {
  ...
}

Crie uma função generatePrompt() para receber a entrada da interface do usuário do comando do 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}`;
    }
  }

Crie uma função getPromptContext() para montar a entrada da interface do usuário com as respostas de exemplo e elaborar o comando completo.

  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 o novo gerenciador de comandos de caracteres, faça o seguinte:

No arquivo wordcraft/app/models/gemini/index.ts, importe o gerenciador de prompt para a nova operação de caractere.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
Adicione uma definição de substituição para o gerenciador de solicitações newCharacter.
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

Para registrar os parâmetros do prompt com a definição do modelo:

No arquivo wordcraft/app/models/model.ts, adicione uma importação para a nova interface NewCharacterPromptParams.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

Adicione parâmetros de solicitação newCharacter à classe de modelo.

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

Teste o novo controle de gravação

Seu novo controle deve estar pronto para ser testado na interface do Wordcraft. Antes de continuar, verifique se há erros de compilação no seu código.

Para testar o novo controle de caracteres, faça o seguinte:

Navegue até o diretório raiz do projeto do Wordcraft.`
```
cd wordcraft/
```
Execute o projeto no modo de desenvolvimento:`
```
npm run dev
```
Em um navegador da Web, acesse a interface do usuário do Wordcraft. O endereço específico é mostrado na saída do comando anterior, por exemplo:
```
http://localhost:3000/
```
No aplicativo Wordcraft, crie uma nova história ou abra uma história existente.
Na área de edição da história, mova o cursor para o final da história. O controle introduzir caractere vai aparecer na guia "Controles" à direita.
No campo introduce caractere, digite uma breve descrição do novo personagem e selecione o botão introduzir caractere.

Outros recursos

Para mais informações sobre o projeto Wordcraft, consulte o repositório de códigos. Para ver as alterações descritas neste tutorial, acesse a solicitação de envio.

Aplicativos de produção

Se você planeja implantar uma versão personalizada do Wordcraft para um grande público, o uso da API Google Gemini pode estar sujeito a limitação de taxa e outras restrições de uso. Se estiver pensando em criar um aplicativo de produção com a API Gemini, como o Docs Agent, confira os serviços da Vertex AI do Google Cloud para aumentar a escalonabilidade e a confiabilidade do seu app.