Funkcja groundingu przy użyciu wyszukiwarki Google jest już dostępna. Więcej informacji

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

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

Uwielbiamy opowieści. Opowiadanie historii i wykonywanie innych form twórczego pisania jest wymagające i satysfakcjonujące. tworzenie własnych artykułów na pustej stronie, jednak może czasem wydawać się przytłaczający, a nawet przytłaczający. Sztuczne modele generatywne AI mogą być doskonałym narzędziem zostawić pustą stronę i utworzyć narrację.

W tym samouczku pokazujemy, Wordcraft, oparte na AI narzędzie do pisania historii stworzone przez zespół Google People and AI Research Ta aplikacja internetowa używa Gemini API do tworzenia historii krok po kroku przez generowanie pomysłów, pisanie fragmentów opowiadania historii i poprawianie treści, aby były bardziej szczegółowe. Możesz modyfikować Wordcrafta aby lepiej dopasować się do Twojego stylu pisania i tworzyć nowe elementy sterujące pisaniem co ułatwi Ci pracę.

Filmowe omówienie projektu i sposobów jego rozszerzenia, w tym statystyki od osób, które go stworzyły, Asystent pisania AI – tworzenie z AI od Google W przeciwnym razie możesz rozpocząć przedłużanie projektu, postępując zgodnie z instrukcjami. poniżej.

Konfigurowanie projektu

Te instrukcje przeprowadzą Cię przez proces konfigurowania projektu Wordcraft programowania i testowania. Musisz zainstalować oprogramowanie wstępne, sklonować projekt z repozytorium kodu, uruchomić instalację konfiguracji oraz ustawić kilka zmiennych środowiskowych. Możesz przetestować konfigurację, uruchamiając projekt po wykonaniu tych czynności.

Zainstaluj wymagania wstępne

Projekt Wordcraft używa węzła i npm do zarządzania i uruchomić aplikację. Poniższe instrukcje instalacji są dla hosta z systemem Linux.

Aby zainstalować wymagane oprogramowanie:

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

Klonowanie i konfigurowanie projektu

Pobierz kod projektu i użyj polecenia instalacyjnego npm, aby go pobrać określić wymagane zależności i skonfigurować projekt. Potrzebujesz oprogramowanie sterujące źródłem git do pobierania projektu. kodu źródłowego.
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 Wordcrafta.
```
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 zezwalania na kod Wordcrafta projekt, który chcesz uruchomić, a w szczególności klucz interfejsu API Gemini Google. podane niżej instrukcje instalacji dotyczą hosta z systemem Linux.

Aby ustawić zmienne środowiskowe:

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

Testowanie konfiguracji

Konfigurację projektu możesz teraz przetestować, uruchamiając Wordcrafta na urządzenia. Ten krok jest opcjonalny, ale zalecany.

Ekran początkowy Wordcrafta

Aby przetestować instalację i konfigurację:

Przejdź do katalogu głównego projektu Wordcrafta.
```
cd wordcraft/
```
Uruchamianie projektu w trybie programistycznym:
```
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/
```

Zmodyfikuj przykładowy tekst promptu

Interfejs użytkownika poleceń Wordcraft Wordcraft tworzy prompty dla generatywnego modelu AI na podstawie zestawu przykładów każdej operacji pomocy w pisaniu, np. rozpoczynania nowej historiii generowania tekstowych. Przykłady określają, jak model generatywny generuje tekst dla: opowiadania historii i przez modyfikację przykładów dla operacji, można zmienić aby zachować zgodność z innym wzorem lub stylem pisania. Takie podejście w prosty sposób, aby Wordcraft mógł pisać dokładnie tak, jak chcesz.

Poniższy przykład pokazuje modyfikację przykładów new_story w Słownictwo. Celem tej modyfikacji jest skierowanie modelu generatywnego AI do Napisz wprowadzenie do opowiadania, stosując wewnętrzny monolog i używając stylu. lepiej sprawdzi się w przypadku kryminałów. Napisanie kilku przykładów Po pierwsze, możesz użyć modelu generatywnego, aby śledzić ogólne , ale stworzyć przedstawienie innego tematu.

Aby zmodyfikować przykłady nowych opowiadań w Wordcraft:

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

Zmodyfikuj przykłady, zachowując ogólną strukturę pliku JSON . Oto przykładowa modyfikacja wprowadzenia do tajemnicy za pomocą wewnętrzny styl 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ę tworzenia nowego artykułu:

Przejdź do katalogu głównego projektu Wordcrafta.
```
cd wordcraft/
```
uruchomić projekt w trybie deweloperskim, Jeśli jest już uruchomiony, możesz zatrzymać aplikację i uruchomić ją ponownie.
```
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 nowego artykułu lub zmień go na inny, a potem wybierz otworzyć nową historię.

Możesz zmienić wszystkie istniejące elementy sterujące pisaniem tekstu w Wordcraft za pomocą tego za pomocą tej metody. Spróbuj zmienić inne elementy sterujące historią, aktualizując przykłady w Katalog wordcraft/app/context/json/.

Utwórz nowy element sterujący pisaniem

Wprowadzający interfejs postaci w Wordcraft Aplikacja Wordcraft została zaprojektowana z myślą o rozszerzaniu pracy, dzięki czemu możesz dodawać nowe teksty pomocne elementy, podobne do generowania tekstu lub modyfikowania zdania; na karcie Ustawienia po prawej stronie aplikacji. Tworzenie wymaga nieco więcej wysiłku, ale pozwala kształtować cechy Wordcraft pasuje do Twojego przepływu pracy i celów.

Poniższa przykładowa modyfikacja powoduje nowy element sterujący dla Słownictwo. Możesz go wykorzystać, aby przedstawić nową postać do historii z opis jego atrybutów. Podstawą kontroli jest taki sam jak inne elementy sterujące Wordcrafta, np. Rozpocznij nową historię. omówiono to wcześniej. Tworzysz plik JSON z kilkoma przykładami, jak chcesz do wprowadzenia. Pozostałe zmiany obejmują interfejs, funkcje zarządzania promptami AI;

Tworzenie przykładów

Napisz kilka przykładów tego, jak chcesz przedstawić model generatywny znaków. Na przykład, czy chcesz je opisać jako lektora, Czy chcesz im przedstawić doświadczenie głównej postaci? W podanych niżej przykładach zastosowano to drugie podejście, polegające na wprowadzeniu nowych postaci z z perspektywy głównej postaci. Dodaj te przykłady za pomocą nowego kodu JSON plik:

Aby dodać przykłady dla 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 zawiera prompt tekst oraz pole target, które zawiera 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 app/context/schema.ts i index.ts zgodnie z treścią promptów w tym nowym interfejsie znaków.

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

Zmodyfikuj plik wordcraft/app/context/schema.ts, tak aby zawierał nowy przykładowej struktury 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 będzie powiązany z tymi nowymi przykładami. Ten nowy pomaga połączyć przykładowe prompty z interfejsem i promptem kodu budynku, który można modyfikować w kolejnych krokach.

Aby utworzyć nowy typ operacji

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

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

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

Zaimportuj nowy schemat w 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 przykładową treść nowego znaku 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>;

Interfejs kompilacji

Po utworzeniu i zarejestrowaniu przykładów generowania treści możesz utwórz interfejs dla nowego elementu sterującego. Duża część pracy w tym zakresie tworzy nową klasę operacji, a następnie rejestruje ją w funkcji głównym kodzie aplikacji Wordcraft.

Aby utworzyć nową operację:

W katalogu wordcraft/app/core/operations/ utwórz plik nowej klasy operacji, używając jednej z istniejących klas operacji jako szablon. Z nowego elementu sterującego znakami możesz skopiować plik new_story_operation.ts klasa i zmień jej nazwę na new_character_operation.ts

Nadaj klasie nową nazwę i określ, kiedy kontrolka ma się pojawić w interfejsu przez zdefiniowanie co najmniej jednej wartości OperationSite.

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

Ustaw 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 promptu do wykorzystania 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 w ramach nowej operacji.
```
import {NewCharacterOperation} from './new_character_operation';
```
W tym samym pliku index.ts dodaj eksport dotyczący NewCharacterOperation zajęcia.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

W pliku wordcraft/app/main.ts zarejestruj nowy .

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

Utwórz obsługę promptów

Ostatnim etapem tworzenia nowego elementu sterującego jest utworzenie kodu, obsługuje generowanie promptów dla modelu generatywnego AI i obsługuje odpowiedź. Głównym elementem pracy jest utworzenie modułu obsługi promptów w interfejsie API Katalog wordcraft/app/models/gemini/prompts/, który pobiera dane wejściowe użytkownika i tworzy prompt, który jest przekazywany do modelu generatywnego.

Aby zdefiniować interfejs parametrów promptów:

W pliku wordcraft/app/core/shared/interfaces.ts dodaj nowych parametrów promptów 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 z użyciem jednej z istniejących klas operacji jako szablon. Z nowego elementu sterującego znakami możesz skopiować plik new_story.ts klasa i zmień jej nazwę na new_character.ts jako punkt wyjścia.

Zdefiniuj funkcję obsługi promptów i zaimportuj NewCharacterExample zajęcia.

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 pobrać dane wejściowe interfejsu użytkownika z promptem 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}`;
    }
  }

Tworzenie funkcji getPromptContext() do zebrania 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łu obsługi promptu dla nowej operacji znaku.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```

Dodaj definicję zastąpienia dla promptu newCharacter .

  override newCharacter = this.makePromptHandler(newCharacter);

Aby zarejestrować parametry promptu za pomocą definicji modelu:

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

Dodaj do klasy modelu parametry promptu newCharacter.

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

Przetestuj nowy element sterujący pisaniem

Nowy element sterujący powinien być gotowy do przetestowania w interfejsie Wordcrafta. Upewnij się, sprawdź, czy w kodzie nie występują błędy kompilacji.

Aby przetestować nowy element sterujący znakami:

Przejdź do katalogu głównego projektu Wordcrafta.`
```
cd wordcraft/
```
Uruchom projekt w trybie programisty:`
```
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ą historię lub otwórz już istniejącą.
W obszarze edycji artykułu umieść kursor na końcu artykułu. W karty Ustawienia po prawej stronie, element sterujący postaci wprowadzającej powinien .
W polu Imię i nazwisko wpisz krótki opis nową postać i wybierz przycisk Przedstaw postać.

Dodatkowe materiały

Więcej informacji o projekcie Wordcraft znajdziesz w kodzie . Możesz zobaczyć zmian opisanych w tym samouczku żądanie pull.

Aplikacje produkcyjne

Jeśli planujesz wdrożyć niestandardową wersję Wordcrafta dla dużej grupy odbiorców, pamiętaj, że korzystanie przez Ciebie z interfejsu Google Gemini API może podlegać ograniczeniom liczby żądań, inny ograniczeniach korzystania. Jeśli rozważasz utworzenie aplikacji produkcyjnej z użyciem interfejsu Gemini API, takiej jak Agent Dokumentów, zapoznaj się Vertex AI Google Cloud usług zwiększających skalowalność i niezawodność aplikacji.