Gemini API की डेवलपर प्रतियोगिता में शामिल हों! ज़्यादा जानें

इस पेज का अनुवाद Cloud Translation API से किया गया है.

Wordक्राफ़्ट की मदद से, एआई (AI) राइटिंग असिस्टेंट बनाएं

हमें कहानियां पसंद हैं. कहानियां सुनाने और क्रिएटिव तरीके से लिखने में चुनौती भरा और फ़ायदेमंद काम हो सकता है. हालांकि, एक खाली पेज से खुद की कहानियां तैयार करना मुश्किल और मुश्किल लग सकता है. आर्टिफ़िशियल इंटेलिजेंस (एआई) जनरेटिव मॉडल एक बेहतरीन टूल हो सकता है. इससे आपको खाली पेजों से बाहर निकलने और अपनी कहानी तैयार करने में मदद मिल सकती है.

इस ट्यूटोरियल में, Wordcraft को ज़्यादा से ज़्यादा लोगों तक पहुंचाने का तरीका बताया गया है. यह टूल, एआई की मदद से काम करने वाला एक स्टोरी लिखने वाला टूल है, जिसे Google की People and AI Research टीम ने बनाया है. यह वेब ऐप्लिकेशन, Gemini API का इस्तेमाल करता है. इसकी मदद से थोड़ा-बहुत आइडिया जनरेट किया जा सकता है, स्टोरी के कुछ हिस्से लिखे जा सकते हैं, और कॉन्टेंट में बदलाव किया जा सकता है, ताकि आपको ज़्यादा जानकारी मिल सके. वर्डक्राफ़्ट में बदलाव किया जा सकता है, ताकि वह आपके लिखने की स्टाइल के हिसाब से सही तरीके से मैच कर सके. साथ ही, लिखने से जुड़े नए कंट्रोल भी बनाए जा सकते हैं, जो आपके वर्कफ़्लो के साथ बेहतर तरीके से काम करते हैं.

प्रोजेक्ट की खास जानकारी और इसे बढ़ाने का तरीका जानने के लिए, एआई राइटिंग असिस्टेंट - Google AI के साथ बनाएं सेक्शन देखें. इसमें प्रोजेक्ट को बनाने वालों से मिली अहम जानकारी भी शामिल है. इसके अलावा, यहां दिए गए निर्देशों का पालन करके, प्रोजेक्ट को आगे बढ़ाया जा सकता है.

प्रोजेक्ट सेटअप

ये निर्देश, डेवलपमेंट और टेस्टिंग के लिए Wordcraft प्रोजेक्ट सेट अप करने में आपकी मदद करते हैं. आपको ज़रूरी सॉफ़्टवेयर इंस्टॉल करना होगा, कोड रिपॉज़िटरी से प्रोजेक्ट का क्लोन बनाना होगा, कॉन्फ़िगरेशन इंस्टॉल करना होगा, और कुछ एनवायरमेंट वैरिएबल सेट करने होंगे. इन चरणों को पूरा करने के बाद, प्रोजेक्ट चलाकर अपने सेटअप की जांच की जा सकती है.

ज़रूरी शर्तें इंस्टॉल करना

Wordcraft प्रोजेक्ट पैकेज मैनेज करने और ऐप्लिकेशन चलाने के लिए, Node और npm का इस्तेमाल करता है. Linux होस्ट मशीन के लिए, इंस्टॉल करने के ये निर्देश हैं.

ज़रूरी सॉफ़्टवेयर इंस्टॉल करने के लिए:

अपने प्लैटफ़ॉर्म के लिए, इंस्टॉल करने के निर्देशों का पालन करके node और npm इंस्टॉल करें.

प्रोजेक्ट का क्लोन बनाएं और उसे कॉन्फ़िगर करें

प्रोजेक्ट कोड डाउनलोड करें और ज़रूरी डिपेंडेंसी डाउनलोड करने और प्रोजेक्ट को कॉन्फ़िगर करने के लिए, npm इंस्टॉलेशन कमांड का इस्तेमाल करें. प्रोजेक्ट सोर्स कोड को फिर से पाने के लिए, आपको git सोर्स कंट्रोल सॉफ़्टवेयर की ज़रूरत होगी.
प्रोजेक्ट कोड को डाउनलोड और कॉन्फ़िगर करने के लिए:

नीचे दिए गए निर्देश का इस्तेमाल करके, गिट रिपॉज़िटरी का क्लोन बनाएं.
```
git clone https://github.com/PAIR-code/wordcraft
```
Wordcraft प्रोजेक्ट की रूट डायरेक्ट्री पर जाएं.
```
cd wordcraft/
```
डिपेंडेंसी डाउनलोड करने के लिए, इंस्टॉल कमांड चलाएं और प्रोजेक्ट को कॉन्फ़िगर करें:
```
npm install
```

एनवायरमेंट वैरिएबल सेट करना

वर्डक्राफ़्ट कोड प्रोजेक्ट को चलाने के लिए ज़रूरी एनवायरमेंट वैरिएबल सेट करें, खास तौर पर Google Gemini API (एपीआई) कुंजी. नीचे दिए गए, Linux होस्ट मशीन के लिए इंस्टॉल करने से जुड़े निर्देश हैं.

एनवायरमेंट वैरिएबल सेट करने के लिए:

Google Gemini API पासकोड पाएं और कुंजी स्ट्रिंग कॉपी करें.
Wordcraft प्रोजेक्ट की रूट डायरेक्ट्री पर जाएं.`
```
cd wordcraft/
```
एपीआई पासकोड को एनवायरमेंट वैरिएबल के तौर पर सेट करें. Linux होस्ट पर, नीचे दिए गए निर्देशों का इस्तेमाल करें.
```
touch .env
echo "API_KEY="<YOUR_API_KEY>"" > .env
```

अपने सेट अप की जांच करना

अब अपने डिवाइस पर Wordcraft चलाकर प्रोजेक्ट के सेटअप की जांच की जा सकती है. यह चरण ज़रूरी नहीं है, फिर भी इसका सुझाव दिया जाता है.

वर्डक्राफ़्ट की शुरुआती स्क्रीन

अपने इंस्टॉलेशन और सेटअप की जांच करने के लिए:

Wordcraft प्रोजेक्ट की रूट डायरेक्ट्री पर जाएं.
```
cd wordcraft/
```
डेवलपमेंट मोड में प्रोजेक्ट चलाना:
```
npm run dev
```
अपने वेब ब्राउज़र में, Wordcraft के यूज़र इंटरफ़ेस पर जाएं. खास पता पिछले निर्देश के आउटपुट में दिखाया जाता है, उदाहरण के लिए:
```
http://localhost:3000/
```

प्रॉम्प्ट के उदाहरण के टेक्स्ट में बदलाव करें

वर्डक्राफ़्ट कमांड का यूज़र इंटरफ़ेस Wordcraft एआई (AI) जनरेटिव मॉडल के लिए प्रॉम्प्ट बनाता है. इसके लिए, वह लिखने में मदद करने वाली हर कार्रवाई के उदाहरणों का इस्तेमाल करता है. जैसे, नई स्टोरी शुरू करें और टेक्स्ट जनरेट करने वाले निर्देश. इन उदाहरणों की मदद से, जनरेटिव मॉडल को आपकी स्टोरी के लिए टेक्स्ट जनरेट करने में मदद मिलेगी. साथ ही, किसी ऑपरेशन के उदाहरणों में बदलाव करके, आउटपुट बदलने के तरीके को अलग पैटर्न या लिखने के तरीके के हिसाब से बदला जा सकता है. इस तरीक़े से Wordcraft को अपनी पसंद के मुताबिक़ लिखने का एक आसान तरीक़ा मिलता है.

नीचे दिए गए उदाहरण में, Wordcraft में new_story के उदाहरणों में किए गए बदलाव को दिखाया गया है. इस बदलाव का मकसद एआई जनरेटिव मॉडल को यह बताना है कि वह इंटरनल मोनोलॉग की मदद से कहानी के शुरुआती हिस्से लिखें. साथ ही, ऐसी शैली का इस्तेमाल करें जो मिस्ट्री नॉवेल के लिए ज़्यादा सही हो. इस तरह की कहानी के बारे में कुछ उदाहरण लिखने पर, आपको जनरेटिव मॉडल मिल सकता है, जो सामान्य पैटर्न का पालन करेगा और किसी दूसरी थीम के लिए परिचय तैयार कर सकता है.

वर्डक्राफ़्ट में कहानी के नई उदाहरणों में बदलाव करने के लिए:

wordcraft/app/context/json/new_story.json फ़ाइल खोलें.

JSON फ़ाइल के स्ट्रक्चर को बनाए रखते हुए, उदाहरणों में बदलाव करें. यहां रहस्यमयी कहानी के परिचय के लिए, इंटरनल मोनोलॉग स्टाइल का इस्तेमाल करके बदलाव करने का एक उदाहरण दिया गया है.

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

`new_story.json` फ़ाइल में किए गए बदलावों को सेव करें.

नई स्टोरी में बदलाव करने की कार्रवाई की जांच करने के लिए:

Wordcraft प्रोजेक्ट की रूट डायरेक्ट्री पर जाएं.
```
cd wordcraft/
```
प्रोजेक्ट को डेवलपमेंट मोड में चलाएं. अगर यह पहले से चल रहा है, तो आपको ऐप्लिकेशन को बंद करके रीस्टार्ट करना पड़ सकता है.
```
npm run dev
```
अपने वेब ब्राउज़र में, Wordcraft के यूज़र इंटरफ़ेस पर जाएं. खास पता पिछले निर्देश के आउटपुट में दिखाया जाता है, उदाहरण के लिए:
```
http://localhost:3000/
```
Wordcraft के मुख्य मेन्यू पर जाएं और नई कहानी शुरू करें को चुनें.
नई स्टोरी के प्रॉम्प्ट को अपडेट करें या उसे अपनी पसंद के मुताबिक सेट करें. इसके बाद, नई स्टोरी शुरू करें को चुनें.

इस तकनीक का इस्तेमाल करके, Wordcraft में कहानी लिखने के सभी मौजूदा कंट्रोल में बदलाव किए जा सकते हैं. wordcraft/app/context/json/ डायरेक्ट्री में उदाहरण अपडेट करके, अन्य स्टोरी कंट्रोल बदलने की कोशिश की जा रही है.

लिखने से जुड़ा नया कंट्रोल बनाएं

वर्डक्राफ़्ट कैरेक्टर का यूज़र इंटरफ़ेस पेश करता है Wordcraft ऐप्लिकेशन को बेहतर तरीके से डिज़ाइन किया गया है, ताकि इसमें आपकी मदद करने के लिए, लिखने से जुड़े नए कंट्रोल जोड़े जा सकें. ये कंट्रोल, ऐप्लिकेशन की दाईं ओर मौजूद कंट्रोल टैब में मौजूद टेक्स्ट जनरेट करने या वाक्य को फिर से लिखने के बटन की तरह होते हैं. इनमें बदलाव करना थोड़ा ज़्यादा आसान होता है, लेकिन इससे आपको अपने वर्कफ़्लो और लक्ष्यों के हिसाब से, Wordcraft की सुविधाओं को बेहतर बनाने में मदद मिलती है.

नीचे दिए गए उदाहरण में, Wordक्राफ़्ट के लिए एक नया कैरेक्टर कंट्रोल बनाया गया है. इसका इस्तेमाल, उस किरदार की विशेषताओं के ब्यौरे के साथ कहानी में एक नए किरदार को दिखाने के लिए किया जा सकता है. इस कंट्रोल की बुनियाद, अन्य Wordcraft कंट्रोल' की तरह ही है. जैसे कि नई स्टोरी शुरू करें कंट्रोल के बारे में पहले चर्चा की गई थी. आपके पास एक JSON फ़ाइल बनाने का विकल्प होता है. इस फ़ाइल में, किरदारों को शामिल करने के कुछ उदाहरण दिए गए हैं. बाकी बदलावों में यूज़र इंटरफ़ेस और एआई प्रॉम्प्ट मैनेजमेंट फ़ंक्शन शामिल हैं.

नमूने बनाना

इस बारे में कुछ उदाहरण लिखें कि जनरेटिव मॉडल आपको वर्णों के बारे में किस तरह बताना चाहता है. उदाहरण के लिए, क्या आपको उन्हें एक नैरेटर की तरह बताना है या उन्हें अपने मुख्य किरदार के अनुभव के ज़रिए बताना है? नीचे दिए गए उदाहरणों में, मुख्य किरदार के नज़रिए से नए किरदारों को पेश करते हुए, बाद वाले तरीके का इस्तेमाल किया गया है. इन उदाहरणों को एक नई JSON फ़ाइल के साथ जोड़ा जाता है:

नए कंट्रोल के उदाहरण जोड़ने के लिए:

wordcraft/app/context/json/new_character.json फ़ाइल बनाएं.

JSON फ़ाइल में उदाहरण बनाएं. इस उदाहरण के लिए, हर उदाहरण में character की जानकारी वाला फ़ील्ड है, जो प्रॉम्प्ट का टेक्स्ट दिखाता है. साथ ही, target फ़ील्ड है, जो अनुमानित आउटपुट दिखाता है.

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

बदलावों को new_character.json फ़ाइल में सेव करें.

उदाहरण बनाने के बाद, app/context/schema.ts और index.ts फ़ाइलों में बदलाव करें, ताकि इस नए कैरेक्टर कंट्रोल के प्रॉम्प्ट कॉन्टेंट को दिखाया जा सके.

schema.ts फ़ाइल में उदाहरण जोड़ने के लिए:

नए वर्ण के उदाहरण वाले डेटा स्ट्रक्चर को शामिल करने के लिए, wordcraft/app/context/schema.ts फ़ाइल में बदलाव करें.
```
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(),
});
```

इन नए उदाहरणों से जुड़े कार्रवाइयों के टाइप तय करें. इस नए टाइप की मदद से, प्रॉम्प्ट के उदाहरणों को यूज़र इंटरफ़ेस और प्रॉम्प्ट बनाने वाले कोड से कनेक्ट किया जा सकता है. इस कोड में, बाद के चरणों में बदलाव किया जाता है.

कोई नया ऑपरेशन टाइप बनाने के लिए

नए वर्ण ऑपरेशन टाइप को जोड़ने के लिए, wordcraft/app/core/shared/types.ts फ़ाइल में बदलाव करें.
```
export const enum OperationType {
  ...
  NEW_CHARACTER = 'NEW_CHARACTER', // add to list of types
  ...
}
```

index.ts फ़ाइल में, उदाहरणों को रजिस्टर करने के लिए:

wordcraft/app/context/index.ts फ़ाइल में, नया स्कीमा इंपोर्ट करें.
```
import {
  continueSchema,
  ...
  newCharacterSchema // add new schema
} from './schema';
```
नई JSON फ़ाइल को newCharacterJson के तौर पर इंपोर्ट करें.
```
import newCharacterJson from './json/new_character.json';
```
ऐप्लिकेशन के कॉन्टेक्स्ट में, नए कैरेक्टर के उदाहरण वाला कॉन्टेंट रजिस्टर करें.
```
export class WordcraftContext {
  constructor() {
  ...
    this.registerExamples(
      OperationType.NEW_CHARACTER,
      newCharacterSchema,
      newCharacterJson
    );
  ...
}
```
NewCharacterExample टाइप एक्सपोर्ट करें.
```
export type NewCharacterExample = z.infer<typeof newCharacterSchema>;
```

बिल्ड यूज़र इंटरफ़ेस

कॉन्टेंट जनरेट करने के उदाहरण बनाने और रजिस्टर करने के बाद, नए कंट्रोल के लिए यूज़र इंटरफ़ेस बनाया जा सकता है. इस चरण में, आपको सबसे ज़्यादा एक नई ऑपरेशन क्लास बनानी होगी. इसके बाद, उस क्लास को Wordcraft ऐप्लिकेशन के मुख्य कोड के साथ रजिस्टर करना होगा.

कोई नई कार्रवाई बनाने के लिए:

wordcraft/app/core/operations/ डायरेक्ट्री में, किसी मौजूदा ऑपरेशन क्लास को टेंप्लेट के तौर पर इस्तेमाल करके, नई ऑपरेशन क्लास बनाएं. नए कैरेक्टर कंट्रोल के लिए, आपके पास new_story_operation.ts क्लास की कॉपी बनाने और उसका नाम बदलकर new_character_operation.ts करने का विकल्प है.
क्लास को एक नया नाम दें और यह तय करें कि यूज़र इंटरफ़ेस में कंट्रोल कब दिखेगा. इसके लिए, OperationSite की कम से कम एक वैल्यू तय करें.
```
export class NewCharacterOperation extends ChoiceOperation {
  static override isAvailable(operationSite: OperationSite) {
    return (
      operationSite === OperationSite.END_OF_SECTION ||
      operationSite === OperationSite.EMPTY_SECTION
    );
  }
```
कार्रवाई के लिए id सेट करें.
```
  static override id = OperationType.NEW_CHARACTER;
```
स्कीमा पैरामीटर की वैल्यू दिखाने के लिए, get और run फ़ंक्शन को अपडेट करें. यह कोड, यूज़र इंटरफ़ेस से प्रॉम्प्ट के टेक्स्ट को एआई प्रॉम्प्ट में इस्तेमाल करने के लिए हैंडल करता है.
```
  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);
  }
```

यूज़र इंटरफ़ेस का टेक्स्ट और जानकारी अपडेट करें.

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

Wordcraft ऐप्लिकेशन में नई कार्रवाई रजिस्टर करने के लिए:

wordcraft/app/core/operations/index.ts फ़ाइल में, नई कार्रवाई के लिए इंपोर्ट जोड़ें.
```
import {NewCharacterOperation} from './new_character_operation';
```
उसी index.ts फ़ाइल में, NewCharacterOperation क्लास के लिए एक्सपोर्ट जोड़ें.
```
export {
  ...
  NewCharacterOperation, // add this class
  ...
};
```

wordcraft/app/main.ts फ़ाइल में, नई कार्रवाई रजिस्टर करें.

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

प्रॉम्प्ट हैंडलिंग का तरीका

नया कंट्रोल बनाने के आखिरी चरण में, आपको ऐसा कोड बनाना होगा जो एआई जनरेटिव मॉडल के लिए प्रॉम्प्ट जनरेट करता हो और रिस्पॉन्स को हैंडल करता हो. इसमें मुख्य तौर पर, wordcraft/app/models/gemini/prompts/ डायरेक्ट्री में एक प्रॉम्प्ट हैंडलर बनाना होता है. यह डायरेक्ट्री, यूज़र इंटरफ़ेस से इनपुट लेती है और जनरेटिव मॉडल में पास किए जाने वाले प्रॉम्प्ट को असेंबल करती है.

प्रॉम्प्ट पैरामीटर के लिए इंटरफ़ेस तय करने के लिए:

wordcraft/app/core/shared/interfaces.ts फ़ाइल में, नए ऑपरेशन की जानकारी देने वाले पैरामीटर के लिए इंटरफ़ेस जोड़ें.
```
export interface NewCharacterPromptParams {
  character: string;
}
```

नई कार्रवाई के लिए प्रॉम्प्ट हैंडलर तय करने का तरीका:

wordcraft/app/models/gemini/prompts/ डायरेक्ट्री में, किसी मौजूदा ऑपरेशन क्लास को टेंप्लेट के तौर पर इस्तेमाल करके, एक नई प्रॉम्प्ट हैंडलर क्लास बनाएं. नए कैरेक्टर कंट्रोल के लिए, new_story.ts क्लास की कॉपी बनाई जा सकती है और शुरुआत की जगह के तौर पर, इसका नाम बदलकर new_character.ts किया जा सकता है.

प्रॉम्प्ट हैंडलर फ़ंक्शन तय करें और 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) {
  ...
}

एआई मॉडल प्रॉम्प्ट के लिए यूज़र इंटरफ़ेस इनपुट पाने के लिए, generatePrompt() फ़ंक्शन बनाएं.

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

यूज़र इंटरफ़ेस इनपुट को उदाहरण के तौर पर दिए गए जवाबों के साथ जोड़ने और पूरा प्रॉम्प्ट बनाने के लिए, getPromptContext() फ़ंक्शन बनाएं.

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

नए कैरेक्टर प्रॉम्प्ट हैंडलर को इंटिग्रेट करने के लिए:

wordcraft/app/models/gemini/index.ts फ़ाइल में, नए कैरेक्टर कार्रवाई के लिए प्रॉम्प्ट हैंडलर इंपोर्ट करें.
```
import {makePromptHandler as newCharacter} from './prompts/new_character';
```
newCharacter प्रॉम्प्ट हैंडलर के लिए, ओवरराइड की परिभाषा जोड़ें.
```
  override newCharacter = this.makePromptHandler(newCharacter);
```

मॉडल डेफ़िनिशन के साथ प्रॉम्प्ट पैरामीटर को रजिस्टर करने के लिए:

wordcraft/app/models/model.ts फ़ाइल में, नए NewCharacterPromptParams इंटरफ़ेस के लिए कोई इंपोर्ट जोड़ें.
```
import {
  ...
  NewCharacterPromptParams,
  ...
} from '@core/shared/interfaces';
```

मॉडल क्लास में newCharacter प्रॉम्प्ट पैरामीटर जोड़ें.

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

लिखने से जुड़े नए कंट्रोल की जांच करें

आपका नया कंट्रोल, Wordcraft के इंटरफ़ेस में आज़माने के लिए तैयार होना चाहिए. आगे बढ़ने से पहले, गड़बड़ियों को कंपाइल करने के लिए अपने कोड की जांच ज़रूर कर लें.

नए कैरेक्टर कंट्रोल की जांच करने के लिए:

Wordcraft प्रोजेक्ट की रूट डायरेक्ट्री पर जाएं.`
```
cd wordcraft/
```
प्रोजेक्ट को डेवलपमेंट मोड में चलाएं:`
```
npm run dev
```
अपने वेब ब्राउज़र में, Wordcraft के यूज़र इंटरफ़ेस पर जाएं. खास पता पिछले निर्देश के आउटपुट में दिखाया जाता है, उदाहरण के लिए:
```
http://localhost:3000/
```
Wordcraft ऐप्लिकेशन में कोई नई कहानी बनाएं या पहले से मौजूद कोई कहानी खोलें.
कहानी में बदलाव करने की जगह में, कर्सर को कहानी के आखिर में ले जाएं. दाईं ओर मौजूद कंट्रोल टैब में, इंट्रोड्यूस कैरेक्टर कंट्रोल दिखेगा.
परिचय वर्ण फ़ील्ड में, नए किरदार के बारे में कम शब्दों में जानकारी लिखें और फिर परिचय वर्ण बटन को चुनें.

ज़्यादा रिसॉर्स

Wordcraft प्रोजेक्ट के बारे में ज़्यादा जानकारी के लिए, कोड डेटा स्टोर करने की जगह देखें. इस ट्यूटोरियल में बताए गए बदलावों को, इस पुल अनुरोध में देखा जा सकता है.

प्रोडक्शन ऐप्लिकेशन

ध्यान दें कि कई लोगों के लिए, अगर Wordcraft के पसंद के मुताबिक बनाए गए वर्शन को डिप्लॉय करना है, तो ध्यान दें कि Google Gemini API का इस्तेमाल, सीमित दर और इस्तेमाल पर दूसरी पाबंदियों के हिसाब से किया जा सकता है. अगर आपको Gemini API की मदद से, Docs Agent जैसे प्रोडक्शन ऐप्लिकेशन बनाना है, तो Google Cloud Vertex AI की सेवाएं देखें. इससे आपको अपने ऐप्लिकेशन को ज़्यादा लोगों तक पहुंचाने और उसे भरोसेमंद बनाने में मदद मिलेगी.