Bergabunglah dalam Kompetisi Developer Gemini API! Pelajari lebih lanjut

Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat asisten penulisan AI dengan Wordcraft

Kita suka cerita. Bercerita dan melakukan bentuk penulisan kreatif lainnya bisa jadi menantang dan bermanfaat. Membangun cerita Anda sendiri dari halaman kosong, bagaimanapun, bisa tampak menakutkan dan bahkan kadang-kadang melelahkan. Model generatif kecerdasan buatan (AI) dapat menjadi alat yang efektif untuk membantu Anda melewati halaman kosong dan membangun narasi.

Tutorial ini menunjukkan cara mengembangkan Wordcraft, alat penulisan cerita yang didukung AI dan dibuat oleh tim People and AI Research Google. Aplikasi web ini menggunakan Gemini API untuk membantu Anda membuat cerita, sedikit demi sedikit dengan membuat ide, menulis bagian-bagian cerita, dan merevisi konten untuk menambahkan detail lebih lanjut. Anda dapat memodifikasi Wordcraft agar lebih cocok dengan gaya penulisan Anda sendiri, dan membuat kontrol penulisan baru untuk lebih mendukung alur kerja Anda.

Untuk ringkasan video project dan cara memperluasnya, termasuk insight dari orang-orang yang membuatnya, lihat AI Writing Assistant - Build with Google AI. Jika tidak, Anda dapat mulai memperluas project dengan mengikuti petunjuk di bawah ini.

Penyiapan project

Petunjuk ini akan memandu Anda menyiapkan project Wordcraft untuk pengembangan dan pengujian. Anda perlu menginstal software prasyarat, meng-clone project dari repositori kode, menjalankan penginstalan konfigurasi, dan menetapkan beberapa variabel lingkungan. Anda dapat menguji penyiapan dengan menjalankan project setelah menyelesaikan langkah-langkah ini.

Menginstal prasyarat

Project Wordcraft menggunakan Node dan npm untuk mengelola paket dan menjalankan aplikasi. Petunjuk penginstalan berikut ditujukan untuk mesin host Linux.

Untuk menginstal software yang diperlukan:

Instal node dan npm dengan mengikuti petunjuk penginstalan untuk platform Anda.

Meng-clone dan mengonfigurasi project

Download kode project dan gunakan perintah penginstalan npm untuk mendownload dependensi yang diperlukan dan mengonfigurasi project. Anda memerlukan software kontrol sumber git untuk mengambil kode sumber project.
Untuk mendownload dan mengonfigurasi kode project:

Clone repositori git menggunakan perintah berikut.

git clone https://github.com/PAIR-code/wordcraft

Buka direktori utama project Wordcraft.
```
cd wordcraft/
```
Jalankan perintah instal untuk mendownload dependensi dan mengonfigurasi project:
```
npm install
```

Menetapkan variabel lingkungan

Tetapkan variabel lingkungan yang diperlukan untuk mengizinkan project kode Wordcraft dijalankan, khususnya Kunci Google Gemini API. Petunjuk penginstalan berikut ditujukan untuk mesin host Linux.

Untuk menetapkan variabel lingkungan:

Dapatkan Kunci API Google Gemini dan salin string kunci.
Buka direktori utama project Wordcraft.`
```
cd wordcraft/
```
Menetapkan Kunci API sebagai variabel lingkungan. Di host Linux, gunakan perintah berikut.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

Menguji penyiapan Anda

Sekarang Anda dapat menguji penyiapan project dengan menjalankan Wordcraft di perangkat. Langkah ini bersifat opsional, tetapi direkomendasikan.

Layar awal Wordcraft

Untuk menguji penginstalan dan penyiapan Anda:

Buka direktori utama project Wordcraft.
```
cd wordcraft/
```
Menjalankan project olehnya dalam mode pengembangan:
```
npm run dev
```
Di browser web, buka antarmuka pengguna Wordcraft. Alamat tertentu ditampilkan dalam output perintah sebelumnya, misalnya:
```
http://localhost:3000/
```

Ubah teks contoh perintah

Antarmuka pengguna perintah Wordcraft Wordcraft membuat perintah untuk model generatif AI menggunakan serangkaian contoh untuk setiap operasi bantuan penulisan, seperti mulai artikel baru dan perintah buat teks. Contoh-contoh tersebut memandu model generatif dalam menghasilkan teks untuk cerita Anda, dan dengan memodifikasi contoh operasi, Anda dapat mengubah output untuk mengikuti pola atau gaya penulisan yang berbeda. Pendekatan ini adalah cara mudah untuk membuat Wordcraft menulis sesuai keinginan Anda.

Contoh berikut menunjukkan modifikasi contoh new_story di Wordcraft. Tujuan dari modifikasi ini adalah mengarahkan model generatif AI untuk menulis pengantar cerita menggunakan pendekatan monolog internal dan menggunakan gaya yang lebih sesuai untuk sebuah novel misteri. Dengan menulis beberapa contoh pengantar cerita semacam ini, Anda bisa mendapatkan model generatif untuk mengikuti pola umum, tetapi membuat pengantar untuk tema yang berbeda.

Untuk mengubah contoh artikel baru di Wordcraft:

Buka file wordcraft/app/context/json/new_story.json.

Ubah contoh sambil mempertahankan struktur file JSON secara keseluruhan. Berikut ini contoh modifikasi untuk pengantar cerita misteri menggunakan gaya monolog internal.

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

Simpan perubahan pada file `new_story.json`.

Untuk menguji operasi cerita baru yang diubah:

Buka direktori utama project Wordcraft.
```
cd wordcraft/
```
Jalankan project dalam mode pengembangan. Jika sudah berjalan, Anda mungkin perlu menghentikan aplikasi dan memulai ulangnya.
```
npm run dev
```
Di browser web, buka antarmuka pengguna Wordcraft. Alamat tertentu ditampilkan dalam output perintah sebelumnya, misalnya:
```
http://localhost:3000/
```
Buka menu utama Wordcraft dan pilih Start a New Story.
Perbarui perintah cerita baru atau ubah sesuai keinginan Anda, lalu pilih mulai cerita baru.

Anda dapat memodifikasi semua kontrol penulisan cerita yang ada di Wordcraft menggunakan teknik ini. Coba ubah kontrol story lainnya dengan memperbarui contoh di direktori wordcraft/app/context/json/.

Membuat kontrol penulisan baru

Wordcraft memperkenalkan antarmuka pengguna karakter Aplikasi Wordcraft dirancang untuk diperluas sehingga Anda dapat menambahkan kontrol penulisan baru untuk membantu Anda, mirip dengan tombol buat teks atau tulis ulang kalimat di tab Kontrol di sisi kanan aplikasi. Perubahan ini memerlukan sedikit lebih banyak upaya, tetapi memungkinkan Anda menyesuaikan fitur Wordcraft agar sesuai dengan alur kerja dan sasaran Anda.

Contoh modifikasi berikut membuat kontrol karakter baru untuk Wordcraft. Anda dapat menggunakannya untuk memperkenalkan karakter baru ke cerita dengan deskripsi atribut karakter tersebut. Fondasi kontrol ini sama dengan kontrol Wordcraft lainnya seperti kontrol mulai cerita baru yang dibahas sebelumnya. Anda membuat file JSON dengan beberapa contoh pengenalan karakter yang Anda inginkan. Perubahan lainnya menambahkan antarmuka pengguna dan fungsi pengelolaan prompt AI.

Membuat contoh

Tulis beberapa contoh bagaimana Anda ingin model generatif memperkenalkan karakter. Misalnya, apakah Anda ingin mendeskripsikannya seperti narator, atau Anda ingin memperkenalkannya melalui pengalaman tokoh utama? Contoh berikut menggunakan pendekatan yang terakhir, yang memperkenalkan karakter baru dari sudut pandang karakter utama. Anda menambahkan contoh-contoh ini dengan file JSON baru:

Untuk menambahkan contoh pada kontrol baru:

Buat file wordcraft/app/context/json/new_character.json.

Buat contoh dalam file JSON. Untuk contoh ini, setiap contoh memiliki kolom deskripsi character, yang mewakili teks perintah, dan kolom target, yang menunjukkan output yang diharapkan.

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

Simpan perubahan pada file new_character.json.

Setelah membuat contoh, ubah file app/context/schema.ts dan index.ts untuk mencerminkan konten perintah kontrol karakter baru ini.

Untuk menambahkan contoh ke file schema.ts:

Ubah file wordcraft/app/context/schema.ts untuk menyertakan contoh struktur data karakter baru.

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

Tentukan jenis operasi yang terkait dengan contoh baru ini. Jenis baru ini akan membantu menghubungkan contoh perintah ke antarmuka pengguna dan kode build perintah, yang Anda ubah pada langkah-langkah selanjutnya.

Untuk membuat jenis operasi baru

Ubah file wordcraft/app/core/shared/types.ts untuk menambahkan jenis operasi karakter baru.

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

Untuk mendaftarkan contoh di file index.ts:

Dalam file wordcraft/app/context/index.ts, impor skema baru.

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

Impor file JSON baru sebagai newCharacterJson.

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

Daftarkan konten contoh karakter baru dalam konteks aplikasi.

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

Ekspor jenis NewCharacterExample.

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

Membangun antarmuka pengguna

Setelah membuat dan mendaftarkan contoh pembuatan konten, Anda dapat membuat antarmuka pengguna untuk kontrol baru. Sebagian besar pekerjaan untuk fase ini adalah membuat class operasi baru, lalu mendaftarkan class tersebut dengan kode utama aplikasi Wordcraft.

Untuk membuat operasi baru:

Dalam direktori wordcraft/app/core/operations/, buat class operasi baru menggunakan salah satu class operasi yang ada sebagai template. Untuk kontrol karakter baru, Anda dapat membuat salinan class new_story_operation.ts dan mengganti namanya menjadi new_character_operation.ts.

Beri nama baru untuk class dan tentukan kapan kontrol muncul di antarmuka pengguna dengan menentukan setidaknya satu nilai OperationSite.

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

Tetapkan id untuk operasi.

  static override id = OperationType.NEW_CHARACTER;

Update fungsi get dan run untuk mencerminkan nilai parameter skema. Kode ini menangani perolehan teks perintah dari antarmuka pengguna untuk digunakan dalam perintah 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);
  }

Perbarui teks dan deskripsi antarmuka pengguna.

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

Untuk mendaftarkan operasi baru di aplikasi Wordcraft:

Dalam file wordcraft/app/core/operations/index.ts, tambahkan impor untuk operasi baru.
```
import {NewCharacterOperation} from './new_character_operation';
```
Dalam file index.ts yang sama, tambahkan ekspor untuk class NewCharacterOperation.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

Dalam file wordcraft/app/main.ts, daftarkan operasi baru.

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

Membuat penanganan prompt

Sebagai fase terakhir pembuatan kontrol baru, Anda membuat kode yang menangani pembuatan perintah untuk model generatif AI dan menangani responsnya. Bagian utama dari pekerjaan ini adalah membangun pengendali prompt di direktori wordcraft/app/models/gemini/prompts/ yang mengambil input dari antarmuka pengguna dan menyusun prompt untuk diteruskan ke model generatif.

Untuk menentukan antarmuka parameter dialog:

Dalam file wordcraft/app/core/shared/interfaces.ts, tambahkan antarmuka untuk parameter yang meminta operasi baru.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

Untuk menentukan pengendali prompt bagi operasi baru:

Dalam direktori wordcraft/app/models/gemini/prompts/, buat class pengendali prompt baru menggunakan salah satu class operasi yang ada sebagai template. Untuk kontrol karakter baru, Anda dapat membuat salinan class new_story.ts dan mengganti namanya menjadi new_character.ts sebagai titik awal.

Tentukan fungsi pengendali perintah dan impor class 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) {
  ...
}

Bangun fungsi generatePrompt() untuk mendapatkan input antarmuka pengguna bagi perintah model 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}`;
    }
  }

Buat fungsi getPromptContext() untuk menyusun input antarmuka pengguna dengan contoh respons dan membangun perintah yang lengkap.

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

Untuk mengintegrasikan pengendali perintah karakter baru:

Dalam file wordcraft/app/models/gemini/index.ts, impor pengendali prompt untuk operasi karakter baru.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
Tambahkan definisi penggantian untuk pengendali perintah newCharacter.
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

Untuk mendaftarkan parameter perintah dengan definisi model:

Dalam file wordcraft/app/models/model.ts, tambahkan impor untuk antarmuka NewCharacterPromptParams baru.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

Tambahkan parameter perintah newCharacter ke class model.

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

Menguji kontrol penulisan baru

Kontrol baru Anda akan siap diuji di antarmuka Wordcraft. Pastikan untuk memeriksa error kompilasi pada kode Anda sebelum melanjutkan.

Untuk menguji kontrol karakter baru:

Buka direktori utama project Wordcraft.`
```
cd wordcraft/
```
Jalankan project dalam mode pengembangan:`
```
npm run dev
```
Di browser web, buka antarmuka pengguna Wordcraft. Alamat tertentu ditampilkan dalam output perintah sebelumnya, misalnya:
```
http://localhost:3000/
```
Di aplikasi Wordcraft, buat cerita baru atau buka cerita yang sudah ada.
Di area pengeditan cerita, arahkan kursor ke akhir cerita. Pada tab Kontrol di sebelah kanan, kontrol perkenalkan karakter akan muncul.
Di kolom perkenalkan karakter, ketik deskripsi singkat tentang karakter baru, lalu pilih tombol perkenalkan karakter.

Referensi tambahan

Untuk mengetahui informasi selengkapnya tentang project Wordcraft, lihat repositori kode. Anda dapat melihat perubahan yang dijelaskan dalam tutorial ini dalam permintaan pull ini.

Aplikasi produksi

Jika Anda berencana men-deploy versi Wordcraft yang disesuaikan untuk audiens dalam jumlah besar, perhatikan bahwa penggunaan Google Gemini API oleh Anda mungkin dikenai pembatasan kapasitas dan pembatasan penggunaan lainnya. Jika Anda mempertimbangkan untuk membangun aplikasi produksi dengan Gemini API seperti Agen Dokumen, lihat layanan Vertex AI Google Cloud untuk meningkatkan skalabilitas dan keandalan aplikasi Anda.