Weź udział w konkursie Gemini API dla programistów. Więcej informacji

Ta strona została przetłumaczona przez Cloud Translation API.

Stwórz asystenta do pisania za pomocą AI w Wordcraft

Uwielbiamy historie. Opowiadanie historii i korzystanie z innych form twórczego pisania może być wyzwaniem i satysfakcjonującym. Tworzenie własnych historii z pustej strony może jednak wydawać się zniechęcające, a nawet przytłaczające. Modele generatywne sztucznej inteligencji (AI) mogą być doskonałym narzędziem, które pomoże Ci wyjść poza pustą stronę i zbudować narrację.

W tym samouczku pokazujemy, jak rozszerzyć możliwości Wordcrafta – opartego na AI narzędzia do pisania narracji opracowanego przez zespół Google ds. badań dotyczących osób i AI. Ta aplikacja internetowa korzysta z interfejsu Gemini API, aby pomagać Ci w tworzeniu historii krok po kroku, generowaniu pomysłów, pisaniu fragmentów historii i poprawianiu treści, tak aby były bardziej szczegółowe. Możesz modyfikować Wordcrafta, aby lepiej dopasować go do swojego stylu pisania, i tworzyć nowe elementy sterujące pisaniem, które usprawniają przepływ pracy.

Film z omówieniem projektu i sposobem jego rozszerzania, w tym informacjami od osób, które go tworzą, znajdziesz w filmie AI Write Assistant – Build with Google AI (Asystent pisania z AI – Build with Google AI). W przeciwnym razie możesz rozszerzyć projekt, postępując zgodnie z poniższymi instrukcjami.

Konfigurowanie projektu

Te instrukcje przeprowadzą Cię przez proces konfigurowania projektu Wordcraft na potrzeby programowania i testowania. Musisz zainstalować wymagane oprogramowanie, skopiować projekt z repozytorium kodu, uruchomić instalację konfiguracji i ustawić kilka zmiennych środowiskowych. Konfigurację możesz przetestować, uruchamiając projekt po wykonaniu tych czynności.

Instalowanie wymagań wstępnych

Projekt Wordcraft wykorzystuje Node i npm do zarządzania pakietami i uruchamiania aplikacji. Poniższe instrukcje instalacji dotyczą hosta z systemem Linux.

Aby zainstalować wymagane oprogramowanie:

Zainstaluj node i npm, postępując zgodnie z instrukcjami instalacji dotyczącymi Twojej platformy.

Klonowanie i konfigurowanie projektu

Pobierz kod projektu i użyj polecenia instalacji npm, aby pobrać wymagane zależności i skonfigurować projekt. Aby pobrać kod źródłowy projektu, musisz mieć oprogramowanie sterujące źródłom git.
Aby pobrać i skonfigurować kod projektu:

Sklonuj repozytorium git za pomocą tego polecenia.
```
git clone https://github.com/PAIR-code/wordcraft
```
Otwórz katalog główny projektu Wordcraft.
```
cd wordcraft/
```
Uruchom polecenie instalacji, aby pobrać zależności i skonfigurować projekt:
```
npm install
```

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe, które są wymagane do uruchomienia projektu z kodem Wordcraft, a w szczególności klucz interfejsu API Google Gemini. Poniższe instrukcje instalacji dotyczą hosta z systemem Linux.

Aby ustawić zmienne środowiskowe:

Pobierz klucz interfejsu API Google Gemini i skopiuj jego ciąg znaków.
Przejdź do katalogu głównego projektu Wordcraft.
```
cd wordcraft/
```
Ustaw klucz interfejsu API jako zmienną środowiskową. Na hostach w systemie Linux użyj tych poleceń.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

Testowanie konfiguracji

Teraz możesz przetestować konfigurację projektu, uruchamiając na swoim urządzeniu Wordcrafta. Ten krok jest opcjonalny, ale zalecany.

Ekran startowy Wordcrafta

Aby przetestować instalację i konfigurację:

Otwórz katalog główny projektu Wordcraft.
```
cd wordcraft/
```
Uruchomienie projektu przez ten projekt w trybie deweloperskim:
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcrafta. Konkretny adres jest widoczny w danych wyjściowych poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```

Zmień przykładowy tekst promptu

Interfejs poleceń Wordcrafta Wordcraft tworzy prompty dla modelu generatywnego AI na podstawie zestawu przykładów dla każdej operacji wspomagającej pisanie, np. Rozpocznij nową opowieść i Wygeneruj tekst. Przykłady pomagają modelowi generatywnemu generować tekst historii, a modyfikując przykłady operacji, możesz zmienić dane wyjściowe tak, aby pasowały do innego wzorca pisania lub innego stylu pisania. To prosty sposób na to, aby tekst w Wordcraft odpowiadał Twoim oczekiwaniom.

Przykład poniżej pokazuje modyfikację przykładów new_story w Wordcraft. Celem tej modyfikacji jest skłonienie modelu generatywnego AI do pisania wstępów do historii przy użyciu podejścia z wykorzystaniem wewnętrznego monologu i stylu, który lepiej pasuje do powieści kryminalnych. Umieszczając kilka przykładów takiego wstępu do historii, możesz wykorzystać model generatywny do podążania za ogólnym schematem, a jednocześnie przygotować wprowadzenie do innego tematu.

Aby zmodyfikować nowe przykłady artykułów w Wordcraft:

Otwórz plik wordcraft/app/context/json/new_story.json.

Zmodyfikuj przykłady, zachowując ogólną strukturę pliku JSON. Oto przykład modyfikacji wprowadzenia do kryminalnej historii przy użyciu stylu wewnętrznego monologu.

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

Zapisz zmiany w pliku „new_story.json”.

Aby przetestować zmodyfikowaną operację artykułu:

Otwórz katalog główny projektu Wordcraft.
```
cd wordcraft/
```
Uruchom projekt w trybie deweloperskim. Jeśli jest już uruchomiona, być może trzeba będzie ją zatrzymać i ponownie uruchomić.
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcrafta. Konkretny adres jest widoczny w danych wyjściowych poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```
Otwórz menu główne Wordcrafta i wybierz Rozpocznij nową historię.
Zaktualizuj prompt lub zmień go na dowolne treści, a potem kliknij Rozpocznij nową relację.

Korzystając z tej metody, możesz zmodyfikować wszystkie dotychczasowe elementy sterujące tekstem w Wordcraft. Próbuję zmienić inne elementy sterujące artykułem, aktualizując przykłady w katalogu wordcraft/app/context/json/.

Utwórz nowy element sterujący pisania

Interfejs postaci z omówieniem w Wordcraft Aplikacja Wordcraft została rozszerzona, dzięki czemu możesz dodawać nowe elementy sterujące pisaniem, podobne do przycisków generowania tekstu i przepisywania zdania na karcie Ustawienia po prawej stronie aplikacji. Wprowadzenie tych zmian jest trochę trudniejsze, ale pozwala dopasować funkcje Wordcrafta do swojego przepływu pracy i celów.

Poniższa przykładowa modyfikacja powoduje utworzenie nowego elementu sterującego znakami w Wordcraft. Możesz go wykorzystać do przedstawienia nowej postaci w historii z opisem jej cech. Podstawy tego elementu sterującego są takie same jak inne elementy sterujące Wordcrafta, takie jak omówione wcześniej kontrolki Rozpocznij nową historię. Tworzysz plik JSON z kilkoma przykładami sposobu wprowadzania znaków. Pozostałe zmiany obejmują interfejs i funkcje zarządzania promptami z AI.

Tworzenie przykładów

Napisz kilka przykładów tego, jak model generatywny ma wprowadzać postacie. Czy chcesz przedstawić ich jako narratora, czy przedstawić doświadczenia głównego bohatera? W poniższych przykładach zastosowano drugie podejście, czyli wprowadzenie nowych postaci z punktu widzenia głównego bohatera. Dodajesz te przykłady w nowym pliku JSON:

Aby dodać przykłady nowego elementu sterującego:

Utwórz plik wordcraft/app/context/json/new_character.json.

Utwórz przykłady w pliku JSON. W tym przykładzie każdy przykład zawiera pole opisu character, które reprezentuje tekst promptu, i pole target, które pokazuje oczekiwane dane wyjściowe.

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

Zapisz zmiany w pliku new_character.json.

Po utworzeniu przykładów zmodyfikuj pliki app/context/schema.ts i index.ts, aby odzwierciedlały treść promptu nowego elementu sterującego znaków.

Aby dodać przykłady do pliku schema.ts:

Zmodyfikuj plik wordcraft/app/context/schema.ts tak, aby zawierał nową przykładową strukturę danych znaków.

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

Zdefiniuj typ operacji, który zostanie powiązany z tymi nowymi przykładami. Ten nowy typ ułatwia połączenie przykładowych promptów z interfejsem i kodem tworzenia promptów, które możesz modyfikować w późniejszych krokach.

Aby utworzyć nowy typ operacji

Zmodyfikuj plik wordcraft/app/core/shared/types.ts, aby dodać nowy typ operacji na znakach.

export const enum OperationType {
  ...
  NEW_CHARACTER = 'NEW_CHARACTER', // add to list of types
  ...
}

Aby zarejestrować przykłady w pliku index.ts:

W pliku wordcraft/app/context/index.ts zaimportuj nowy schemat.

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

Zaimportuj nowy plik JSON jako newCharacterJson.

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

Zarejestruj nową, przykładową treść znaków w kontekście aplikacji.

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

Wyeksportuj typ NewCharacterExample.

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

Utwórz interfejs użytkownika

Po utworzeniu i zarejestrowaniu przykładów generowania treści możesz utworzyć interfejs dla nowego elementu sterującego. Większość pracy na tym etapie polega na utworzeniu nowej klasy operacji, a następnie zarejestrowaniu jej za pomocą głównego kodu aplikacji Wordcraft.

Aby utworzyć nową operację:

W katalogu wordcraft/app/core/operations/ utwórz nową klasę operacji, używając jednej z istniejących klas operacji jako szablonu. W przypadku nowego elementu sterującego znakami możesz utworzyć kopię klasy new_story_operation.ts i zmienić jej nazwę na new_character_operation.ts.

Nadaj klasie nową nazwę i określ, kiedy element sterujący pojawi się w interfejsie, definiując co najmniej 1 wartość OperationSite.

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

Ustaw id operacji.

  static override id = OperationType.NEW_CHARACTER;

Zaktualizuj funkcje get i run, aby odzwierciedlały wartości parametrów schematu. Ten kod obsługuje pobieranie tekstu promptu z interfejsu użytkownika w celu użycia go w prompcie AI.

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

Zaktualizuj tekst i opisy interfejsu.

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

Aby zarejestrować nową operację w aplikacji Wordcraft:

W pliku wordcraft/app/core/operations/index.ts dodaj import dla nowej operacji.
```
import {NewCharacterOperation} from './new_character_operation';
```
W tym samym pliku index.ts dodaj eksport dla klasy NewCharacterOperation.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

W pliku wordcraft/app/main.ts zarejestruj nową operację.

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

Utwórz obsługę promptów

Na ostatnim etapie tworzenia nowego elementu sterującego tworzysz kod, który generuje prompty dla modelu generatywnego AI i obsługuje odpowiedź. Głównym elementem pracy jest utworzenie w katalogu wordcraft/app/models/gemini/prompts/ modułu obsługi promptów, który pobiera dane wejściowe z interfejsu użytkownika i tworzy prompt, który ma zostać przekazany do modelu generatywnego.

Aby zdefiniować interfejs parametrów promptów:

W pliku wordcraft/app/core/shared/interfaces.ts dodaj interfejs dla parametrów promptów dla nowych operacji.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Aby zdefiniować moduł obsługi promptów dla nowej operacji:

W katalogu wordcraft/app/models/gemini/prompts/ utwórz nową klasę obsługi promptów, używając jednej z istniejących klas operacji jako szablonu. W przypadku nowego elementu sterującego znakami możesz utworzyć kopię klasy new_story.ts i zmienić jej nazwę na new_character.ts jako punkt początkowy.

Zdefiniuj funkcję obsługi promptów i zaimportuj klasę 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) {
  ...
}

Utwórz funkcję generatePrompt(), która będzie pobierać dane wejściowe interfejsu dla promptu modelu AI.

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

Utwórz funkcję getPromptContext(), aby zgromadzić dane wejściowe interfejsu użytkownika z przykładowymi odpowiedziami i utworzyć pełny prompt.

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

Aby zintegrować nowy moduł obsługi promptów znaków:

W pliku wordcraft/app/models/gemini/index.ts zaimportuj moduł obsługi promptu dla nowej operacji na znakach.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
Dodaj definicję zastąpienia dla modułu obsługi promptów newCharacter.
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

Aby zarejestrować parametry promptu w definicji modelu:

W pliku wordcraft/app/models/model.ts dodaj import do nowego interfejsu NewCharacterPromptParams.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

Dodaj do klasy modelu parametry prośby (newCharacter).

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

Przetestuj nowy element sterowania pisaniem

Twój nowy element sterujący powinien być gotowy do przetestowania w interfejsie Wordcrafta. Zanim przejdziesz dalej, sprawdź, czy kod nie zawiera błędów kompilacji.

Aby przetestować nowy element sterujący znakami:

Przejdź do katalogu głównego projektu Wordcraft.
```
cd wordcraft/
```
Uruchom projekt w trybie deweloperskim:
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcrafta. Konkretny adres jest widoczny w danych wyjściowych poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```
W aplikacji Wordcraft utwórz nową opowieść lub otwórz istniejącą.
W obszarze edycji artykułu przesuń kursor na koniec artykułu. Na karcie Ustawienia po prawej stronie powinien pojawić się znak wprowadzenia.
W polu znaku wprowadzającego wpisz krótki opis nowego znaku i kliknij przycisk znaku wprowadzającego.

Dodatkowe materiały

Więcej informacji o projekcie Wordcraft znajdziesz w repozytorium kodu. Zmiany opisane w tym samouczku możesz wyświetlić w tym żądaniu pull.

Aplikacje produkcyjne

Jeśli planujesz wdrożyć niestandardową wersję Wordcrafta dla dużej grupy odbiorców, pamiętaj, że korzystanie z interfejsu Google Gemini API może podlegać ograniczeniom liczby żądań i innym ograniczeniom korzystania. Jeśli zastanawiasz się nad utworzeniem aplikacji produkcyjnej za pomocą interfejsu Gemini API, np. Document Agent, zapoznaj się z usługami Google Cloud Vertex AI, aby zapewnić większą skalowalność i niezawodność aplikacji.