Gemini 2.0 Flash jest już gotowy do wdrożenia w produkcji. 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. Pisanie opowiadań i inne formy kreatywnego pisania mogą być wyzwaniem, ale też przynosić satysfakcję. Tworzenie własnych relacji od zera może być jednak przytłaczające, a czasem wręcz przytłaczające. Modele generatywne sztucznej inteligencji (AI) mogą być świetnym narzędziem do tworzenia treści na pustej stronie.

W tym samouczku pokazujemy, jak rozszerzyć Wordcraft, czyli narzędzie do pisania historii oparte na AI, opracowane przez zespół ds. badań nad ludźmi i sztuczną inteligencją w Google. Ta aplikacja internetowa korzysta z interfejsu Gemini API, aby pomóc Ci w krok po kroku tworzyć historie, generując pomysły, pisząc części swoich historii i poprawiając treści, aby dodać więcej szczegółów. Możesz zmodyfikować Wordcraft, aby lepiej dopasować go do swojego stylu pisania, i tworzyć nowe opcje pisania, aby lepiej wspierać swój przepływ pracy.

Filmowy przegląd projektu i jego rozszerzania, w tym wskazówki od jego twórców, znajdziesz w artykule AI Writing Assistant – tworzenie z użyciem AI od Google. W przeciwnym razie możesz zacząć rozszerzać projekt, postępując zgodnie z instrukcjami podanymi poniżej.

Konfigurowanie projektu

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

Instalowanie wymagań wstępnych

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

Aby zainstalować wymagane oprogramowanie:

Zainstaluj node i npm, postępując zgodnie z instrukcjami instalacji dla danej 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 do kontroli wersji git.
Aby pobrać i skonfigurować kod projektu:

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

Ustawianie zmiennych środowiskowych

Ustaw zmienne środowiskowe wymagane do uruchomienia projektu kodu Wordcraft, w szczególności klucza Google Gemini API. Poniższe instrukcje instalacji dotyczą komputera z systemem Linux.

Aby ustawić zmienne środowiskowe:

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

Testowanie konfiguracji

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

Ekran startowy Wordcraft

Aby przetestować instalację i konfigurację:

Przejdź do katalogu głównego projektu Wordcraft.
```
cd wordcraft/
```
Uruchamianie projektu w trybie deweloperskim:
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcraft. Adres konkretny wyświetla się w wyniku poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```

Modyfikowanie przykładowego tekstu promptu

Interfejs poleceń Wordcraft Wordcraft tworzy prompty dla modelu generatywnego AI, korzystając z zestawu przykładów dla każdej operacji wspomagania pisania, takiej jak polecenia start new story i generate text. Przykłady kierują modelem generacyjnym podczas generowania tekstu do Twojej historii. Modyfikując przykłady dla danej operacji, możesz zmienić wynik, aby był zgodny z innym wzorcem lub stylem pisania. To proste podejście pozwala Wordcraftowi pisać w sposób, który Ci odpowiada.

Ten przykład pokazuje modyfikację przykładów new_story w Wordcraft. Celem tej modyfikacji jest kierowanie modelem generatywnej AI do pisania wstępów do historii z użyciem dialogu wewnętrznego i stylu bardziej odpowiedniego dla powieści kryminalnej. Dzięki napisaniu kilku przykładów tego rodzaju wstępu do artykułu możesz sprawić, że model generatywny będzie stosować ogólny wzór, ale wygeneruje wstęp do innego tematu.

Aby zmodyfikować nowe przykłady historii w Wordcraft:

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

Modyfikuj przykłady, zachowując ogólną strukturę pliku JSON. Oto przykład modyfikacji wprowadzenia do powieści detektywistycznej, w której zastosowano styl 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ę dotyczącą nowego artykułu:

Przejdź do katalogu głównego projektu Wordcraft.
```
cd wordcraft/
```
Uruchom projekt w trybie programowania. Jeśli aplikacja jest już uruchomiona, może być konieczne jej zatrzymanie i ponowne uruchomienie.
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcraft. Adres konkretny wyświetla się w wyniku poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```
Otwórz menu główne programu Wordcraft i wybierz Rozpocznij nową historię.
Zaktualizuj prompt dotyczący nowej historii lub zmień go, a następnie wybierz Rozpocznij nową historię.

Za pomocą tej techniki możesz modyfikować wszystkie istniejące elementy sterujące pisaniem scenariusza w Wordcraft. Spróbuj zmienić inne ustawienia historii, aktualizując przykłady w katalogu wordcraft/app/context/json/.

Tworzenie nowego elementu sterującego do pisania

Wordcraft wprowadza interfejs postaci Aplikacja Wordcraft została zaprojektowana tak, aby można było dodawać do niej nowe opcje, które ułatwią Ci pisanie. Przykładem są przyciski generowania tekstu lub przepisywania zdania na karcie „Opcje” po prawej stronie aplikacji. Wprowadzanie tych modyfikacji wymaga nieco więcej wysiłku, ale pozwala dostosować funkcje Wordcraft do swoich potrzeb i celów.

W tym przykładzie modyfikacji tworzymy nowy element sterujący postacią w grze Wordcraft. Możesz go użyć, aby przedstawić nowego bohatera w historii z opisem jego atrybutów. Podstawa tej funkcji jest taka sama jak innych funkcji Wordcraft, takich jak rozpoczęcie nowej historii, o której była mowa wcześniej. Utwórz plik JSON z kilkoma przykładami wprowadzania znaków. Pozostałe zmiany dotyczą interfejsu użytkownika i funkcji zarządzania promptami AI.

Tworzenie przykładów

Podaj kilka przykładów, jak model generatywny ma wprowadzać postacie. Czy chcesz na przykład opisać je w postaci narratora, czy raczej przedstawić za pomocą doświadczeń głównego bohatera? W następujących przykładach zastosowano to drugie podejście, wprowadzając nowych bohaterów z perspektywy głównego bohatera. Dodajesz te przykłady za pomocą nowego 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 ma pole character z opisem, które zawiera prompt, oraz pole target z oczekiwanym wynikiem.

[
  {
    "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 odzwierciedlić zawartość promptu nowego elementu sterującego postacią.

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

Zmodyfikuj plik wordcraft/app/context/schema.ts, aby uwzględnić nową strukturę danych przykładowego znaku.

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

Określ typ operacji powiązany z tymi nowymi przykładami. Ten nowy typ pomaga połączyć przykłady promptów z interfejsem użytkownika i kodem służącym do tworzenia promptów, który zmodyfikujesz w późniejszych krokach.

Tworzenie nowego typu operacji

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

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

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

Zaimportuj nowy schemat do pliku wordcraft/app/context/index.ts.

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

Zaimportuj nowy plik JSON jako newCharacterJson.

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

Zarejestruj nowy przykładowy tekst w kontekście aplikacji.

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

Eksportuj typ NewCharacterExample.

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

Tworzenie interfejsu użytkownika

Po utworzeniu i zarejestrowaniu przykładów generowania treści możesz utworzyć interfejs użytkownika dla nowego elementu sterującego. Większość pracy w tej fazie polega na tworzeniu nowej klasy operacji, a następnie rejestrowaniu jej w głównym kodzie aplikacji Wordcraft.

Aby utworzyć nową operację:

W katalogu wordcraft/app/core/operations/ utwórz nową klasę operacji, używając jako szablonu jednej z dotychczasowych klas operacji. W przypadku nowej kontroli znaków 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 kontrolka ma się pojawiać w interfejsie użytkownika, definiując co najmniej jedną wartość OperationSite.

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

Ustaw wartość id dla 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 prompta z interfejsu użytkownika na potrzeby promptu 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 zajęć 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
  ...
);

Tworzenie obsługi prompta

Ostatnim etapem tworzenia nowej funkcji jest utworzenie kodu, który będzie generować prompty dla generatywnego modelu AI i obsługiwać odpowiedzi. Głównym zadaniem jest stworzenie w katalogu wordcraft/app/models/gemini/prompts/ modułu obsługi promptów, który będzie przyjmować dane wejściowe z interfejsu użytkownika i tworzyć prompty do przekazania do modelu generatywnego.

Aby zdefiniować interfejs dla parametrów prompta:

W pliku wordcraft/app/core/shared/interfaces.ts dodaj interfejs dla nowych operacji promptujących parametry.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Aby zdefiniować w ramach nowej operacji uchwyt zachęty:

W katalogu wordcraft/app/models/gemini/prompts/ utwórz nową klasę obsługi prompta, używając jako szablonu jednej z dotychczasowych klas operacji. W przypadku nowej kontroli postaci możesz utworzyć kopię klasy new_story.ts i zmienić jej nazwę na new_character.ts, aby użyć jej jako punktu wyjścia.

Zdefiniuj funkcję obsługi prompta 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(), aby uzyskać dane wejściowe interfejsu użytkownika na potrzeby 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 z danych wejściowych interfejsu użytkownika utworzyć przykładowe odpowiedzi i kompletny 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ć nowego modułu obsługi promptu dotyczącego znaków:

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

Aby zarejestrować parametry promptu w definicji modelu:

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

Dodaj do klasy modelu parametry prompta newCharacter.

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

Testowanie nowego elementu sterującego pisaniem

Nowy element sterujący powinien być gotowy do przetestowania w interfejsie Wordcraft. Zanim przejdziesz dalej, sprawdź kod pod kątem błędów kompilacji.

Aby przetestować nowe sterowanie postacią:

Przejdź do katalogu głównego projektu Wordcraft.
```
cd wordcraft/
```
Uruchom projekt w trybie programistycznym:
```
npm run dev
```
W przeglądarce otwórz interfejs Wordcraft. Adres konkretny wyświetla się w wyniku poprzedniego polecenia, na przykład:
```
http://localhost:3000/
```
W aplikacji Wordcraft utwórz nową historię lub otwórz istniejącą.
W obszarze edycji artykułu przenieś kursor na koniec artykułu. Na karcie Elementy sterujące po prawej stronie powinna pojawić się opcja Wprowadzenie postaci.
W polu introduce character (Przedstaw bohatera) wpisz krótki opis nowego bohatera, a potem kliknij przycisk introduce character (Przedstaw bohatera).

Dodatkowe materiały

Więcej informacji o projekcie Wordcraft znajdziesz w repozytorium kodu. Zmiany opisane w tym samouczku możesz zobaczyć w tym pull request.

Aplikacje produkcyjne

Jeśli planujesz wdrożenie niestandardowej wersji Wordcraft dla dużej liczby odbiorców, pamiętaj, że korzystanie z interfejsu Gemini API Google może podlegać ograniczeniom szybkości i innym ograniczeniami użycia. Jeśli rozważasz stworzenie aplikacji produkcyjnej z użyciem interfejsu Gemini API, takiej jak agent Docs, zapoznaj się z usługami Google Cloud Vertex AI, aby zwiększyć skalowalność i niezawodność aplikacji.