Perujukan dengan Google Penelusuran kini tersedia. Pelajari lebih lanjut

Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat asisten penulisan AI dengan Wordcraft

Kami suka cerita. Bercerita dan melakukan bentuk tulisan kreatif lainnya dapat menantang dan bermanfaat. Menyusun cerita Anda sendiri dari halaman kosong, namun, terkadang terlihat sangat sulit dan bahkan membebani. Artifisial model generatif yang cerdas (AI) dapat menjadi alat yang efektif untuk membantu Anda melewati kosong dan membangun narasi Anda.

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

Untuk video ringkasan proyek dan cara memperluasnya, termasuk wawasan dari orang-orang yang membuatnya, lihat Asisten Penulisan AI - Membangun dengan AI Google. Jika tidak, Anda dapat mulai memperpanjang project dengan mengikuti petunjuk di bawah ini.

Penyiapan project

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

Instal prasyarat

Project Wordcraft menggunakan Node dan npm untuk mengelola paket dan menjalankan aplikasi. Petunjuk penginstalan berikut adalah untuk mesin {i>host<i} 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 perlu git software kontrol sumber untuk mengambil project pada kode sumber Anda.
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

Menyetel variabel lingkungan yang diperlukan untuk mengizinkan kode Wordcraft project yang ingin dijalankan, khususnya Kunci Gemini API Google. Tujuan petunjuk instalasi berikut ditujukan untuk mesin {i>host<i} Linux.

Untuk menetapkan variabel lingkungan:

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

Menguji penyiapan Anda

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

Layar awal Wordcraft

Untuk menguji penginstalan dan penyiapan:

Buka direktori utama project Wordcraft.
```
cd wordcraft/
```
Menjalankan project dengannya dalam mode pengembangan:
```
npm run dev
```
Di browser web, buka antarmuka pengguna Wordcraft. Tujuan 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 memulai cerita baru dan membuat teks. Contoh-contoh tersebut memandu model generatif dalam menghasilkan teks untuk cerita Anda, dan dengan memodifikasi contoh untuk suatu operasi, Anda dapat mengubah {i>output<i} untuk mengikuti pola atau gaya penulisan yang berbeda. Pendekatan ini adalah cara sederhana untuk membuat Wordcraft menulis sesuai keinginan Anda.

Contoh berikut menunjukkan modifikasi dari contoh new_story di Wordcraft. Tujuan dari modifikasi ini adalah untuk mengarahkan model generatif AI ke tulis pengantar cerita menggunakan pendekatan monolog internal dan gunakan gaya yang lebih cocok untuk novel misteri. Dengan menulis beberapa contoh pengantar cerita ini, Anda bisa membuat model generatif mengikuti tapi membuat pengantar untuk tema yang berbeda.

Untuk mengubah contoh cerita baru di Wordcraft:

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

Mengubah contoh sambil mempertahankan keseluruhan struktur JSON . Berikut adalah contoh modifikasi 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 dimodifikasi:

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

Anda dapat memodifikasi semua kontrol penulisan cerita yang ada di Wordcraft menggunakan standar. Mencoba mengubah kontrol cerita lainnya dengan memperbarui contoh di Direktori wordcraft/app/context/json/.

Buat kontrol penulisan baru

Wordcraft memperkenalkan antarmuka pengguna karakter Aplikasi Wordcraft dirancang untuk diperluas sehingga Anda dapat menambahkan tulisan baru kontrol untuk membantu Anda, serupa dengan membuat teks atau menulis ulang kalimat di tab Kontrol di sisi kanan aplikasi. Membuat modifikasi membutuhkan lebih banyak usaha, tetapi memungkinkan Anda untuk membentuk fitur Wordcraft sesuai dengan alur kerja dan sasaran Anda.

Contoh modifikasi berikut membuat kontrol karakter baru untuk Wordcraft. Anda dapat menggunakannya untuk memperkenalkan karakter baru ke dalam cerita dengan deskripsi atribut dari karakter tersebut. Dasar dari kontrol ini sama dengan kontrol Wordcraft lainnya seperti kontrol mulai cerita baru telah kita bahas sebelumnya. Anda membuat file JSON dengan beberapa contoh cara yang Anda inginkan karakter yang akan diperkenalkan. Perubahan lainnya menambahkan antarmuka pengguna dan Fungsi pengelolaan perintah AI.

Membuat contoh

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

Untuk menambahkan contoh kontrol baru:

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

Buat contoh di file JSON. Untuk contoh ini, setiap contoh memiliki kolom deskripsi character, yang mewakili perintah teks, 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 app/context/schema.ts dan index.ts untuk mencerminkan konten prompt kontrol karakter baru ini.

Untuk menambahkan contoh ke file schema.ts:

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

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. Fitur baru ini membantu menghubungkan contoh perintah ke antarmuka pengguna dan prompt kode bangunan, yang akan Anda ubah di langkah-langkah berikutnya.

Untuk membuat jenis operasi baru

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

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

Untuk mendaftarkan contoh dalam 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 ini adalah membuat kelas operasi baru dan kemudian mendaftarkan kelas tersebut dengan kode utama aplikasi Wordcraft.

Untuk membuat operasi baru:

Di direktori wordcraft/app/core/operations/, buat sebuah baru menggunakan salah satu kelas operasi yang ada sebagai {i>template<i}. Untuk kontrol karakter baru, Anda bisa membuat salinan new_story_operation.ts class dan mengganti namanya menjadi new_character_operation.ts.

Beri nama baru untuk class tersebut, dan tentukan kapan kontrol akan 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 parameter skema. Kode ini menangani proses mendapatkan 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:

Di file wordcraft/app/core/operations/index.ts, tambahkan 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
  ...
};
```

Di file wordcraft/app/main.ts, daftarkan versi baru operasi.

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

Membuat penanganan prompt

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

Untuk menentukan antarmuka parameter prompt:

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

Untuk menentukan pengendali perintah untuk operasi baru:

Di direktori wordcraft/app/models/gemini/prompts/, buat class pengendali prompt baru menggunakan salah satu kelas operasi yang ada {i>template<i}. Untuk kontrol karakter baru, Anda bisa membuat salinan new_story.ts class dan mengganti namanya menjadi new_character.ts sebagai titik awal.

Menentukan fungsi pengendali prompt dan mengimpor 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 untuk prompt 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 pengguna dengan contoh respons dan membuat prompt 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 prompt karakter baru:

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

Untuk mendaftarkan parameter prompt dengan definisi model:

Di file wordcraft/app/models/model.ts, tambahkan impor untuk antarmuka NewCharacterPromptParams yang 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 ada tidaknya kompilasi pada kode 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. Tujuan 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 bagian akhir cerita. Di beberapa tab Kontrol di sebelah kanan, kontrol karakter perkenalan harus akan muncul.
Pada bidang perkenalkan karakter, ketik deskripsi singkat tentang karakter baru, lalu pilih tombol perkenalkan karakter.

Referensi lainnya

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

Aplikasi produksi

Jika Anda berencana menggunakan versi Wordcraft yang disesuaikan untuk audiens yang besar, perhatikan bahwa penggunaan Gemini API oleh Anda mungkin tunduk kepada pembatasan kapasitas dan lainnya pembatasan penggunaan. Jika Anda mempertimbangkan untuk membangun aplikasi produksi dengan Gemini API seperti Agen Dokumen, lihat Vertex AI Google Cloud untuk meningkatkan skalabilitas dan keandalan aplikasi Anda.