कॉन्टेंट जनरेट किया जा रहा है

Firebase Genkit, एलएलएम की मदद से कॉन्टेंट जनरेट करने के लिए एक आसान इंटरफ़ेस उपलब्ध कराता है.

मॉडल

Firebase Genkit में मॉडल, लाइब्रेरी और ऐब्स्ट्रैक्ट होते हैं. इनकी मदद से, Google और Google से बाहर के एलएलएम.

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

Genkit में मॉडल का इस्तेमाल करते समय, आपको सबसे पहले वह मॉडल कॉन्फ़िगर करना होगा काम करना चाहते हैं. मॉडल कॉन्फ़िगरेशन, प्लगिन सिस्टम की मदद से किया जाता है. तय सीमा में इस उदाहरण में, Vertex AI प्लगिन को कॉन्फ़िगर किया जा रहा है, जो Gemini को मॉडल.

शुरू करें

import "github.com/firebase/genkit/go/ai"
import "github.com/firebase/genkit/go/plugins/vertexai"

// Default to the value of GCLOUD_PROJECT for the project,
// and "us-central1" for the location.
// To specify these values directly, pass a vertexai.Config value to Init.
if err := vertexai.Init(ctx, nil); err != nil {
  return err
}

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

शुरू करें

gemini15pro := vertexai.Model("gemini-1.5-pro")

इस्तेमाल किए जा सकने वाले मॉडल

Genkit अपने प्लगिन सिस्टम की मदद से, मॉडल से जुड़ी सहायता उपलब्ध कराता है. नीचे दिए गए प्लग इन आधिकारिक रूप से समर्थित हैं:

प्लग इन मॉडल
Google का जनरेटिव एआई Gemini Pro और Gemini Pro Vision
Google Vertex AI Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
ओलामा कई लोकल मॉडल, जैसे कि Gemma, Llama 2, Mistral वगैरह

सेटअप और उपयोग की जानकारी के लिए प्रत्येक प्लग इन के लिए दस्तावेज़ देखें.

कॉन्टेंट जनरेट करने का तरीका

Genkit, मॉडल की मदद से कॉन्टेंट जनरेट करने के लिए एक आसान हेल्पर फ़ंक्शन देता है.

केवल मॉडल को कॉल करने के लिए:

शुरू करें

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")}},
}}
response, err := gemini15pro.Generate(ctx, &request, nil)
if err != nil {
  return err
}

responseText, err := response.Text()
if err != nil {
  return err
}
fmt.Println(responseText)

आपके पास मॉडल कॉल के साथ-साथ अन्य विकल्प भी पास करने का विकल्प होता है. इस्तेमाल किए जा सकने वाले विकल्प यह मॉडल और उसके एपीआई पर निर्भर करता है.

शुरू करें

request := ai.GenerateRequest{
  Messages: []*ai.Message{
      {Content: []*ai.Part{ai.NewTextPart("Tell me a joke about dogs.")}},
  },
  Config: ai.GenerationCommonConfig{
      Temperature:     1.67,
      StopSequences:   []string{"abc"},
      MaxOutputTokens: 3,
  },
}

जवाब स्ट्रीम किए जा रहे हैं

Genkit, मॉडल के जवाबों को अलग-अलग हिस्सों में स्ट्रीम करने की सुविधा देता है:

शुरू करें

अलग-अलग हिस्सों में स्ट्रीम करने की सुविधा का इस्तेमाल करने के लिए, Generate() को कॉलबैक फ़ंक्शन पास करें:

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{ai.NewTextPart("Tell a long story about robots and ninjas.")}},
}}
response, err := gemini15pro.Generate(
  ctx,
  &request,
  func(ctx context.Context, grc *ai.GenerateResponseChunk) error {
      text, err := grc.Text()
      if err != nil {
          return err
      }
      fmt.Printf("Chunk: %s\n", text)
      return nil
  })
if err != nil {
  return err
}

// You can also still get the full response.
responseText, err := response.Text()
if err != nil {
  return err
}
fmt.Println(responseText)

मल्टीमोडल इनपुट

अगर मॉडल मल्टीमॉडल इनपुट के साथ काम करता है, तो आपके पास इमेज प्रॉम्प्ट पास करने का विकल्प होता है:

शुरू करें

imageBytes, err := os.ReadFile("img.jpg")
if err != nil {
  return err
}
encodedImage := base64.StdEncoding.EncodeToString(imageBytes)

request := ai.GenerateRequest{Messages: []*ai.Message{
  {Content: []*ai.Part{
      ai.NewTextPart("Describe the following image."),
      ai.NewMediaPart("", "data:image/jpeg;base64,"+encodedImage),
  }},
}}
gemini15pro.Generate(ctx, &request, nil)

इमेज प्रॉम्प्ट का फ़ॉर्मैट (https यूआरएल, gs यूआरएल, data यूआरआई) यह है मॉडल पर निर्भर करता है.

फ़ंक्शन कॉलिंग (टूल)

Genkit मॉडल, फ़ंक्शन कॉलिंग के लिए इंटरफ़ेस उपलब्ध कराता है. इससे, उन मॉडल को इस्तेमाल करने में मदद मिलती है जो इसे.

शुरू करें

myJoke := &ai.ToolDefinition{
  Name:        "myJoke",
  Description: "useful when you need a joke to tell",
  InputSchema: make(map[string]any),
  OutputSchema: map[string]any{
      "joke": "string",
  },
}
ai.DefineTool(
  myJoke,
  nil,
  func(ctx context.Context, input map[string]any) (map[string]any, error) {
      return map[string]any{"joke": "haha Just kidding no joke! got you"}, nil
  },
)

request := ai.GenerateRequest{
  Messages: []*ai.Message{
      {Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")},
          Role: ai.RoleUser},
  },
  Tools: []*ai.ToolDefinition{myJoke},
}
response, err := gemini15pro.Generate(ctx, &request, nil)

इससे उपयोगकर्ता के प्रॉम्प्ट को पूरा करने के लिए, टूल को अपने-आप कॉल कर दिया जाएगा.

मैसेज का इतिहास रिकॉर्ड किया जा रहा है

Genkit मॉडल, मॉडल को भेजे गए मैसेज के इतिहास को बनाए रखने में मदद करता है और उसके जवाब, जिनका इस्तेमाल इंटरैक्टिव अनुभव तैयार करने में किया जा सकता है, जैसे कि चैटबॉट.

शुरू करें

सेशन के पहले प्रॉम्प्ट में, "इतिहास" उपयोगकर्ता का प्रॉम्प्ट ही है:

history := []*ai.Message{{
  	Content: []*ai.Part{ai.NewTextPart(prompt)},
  	Role:    ai.RoleUser,
  }}

request := ai.GenerateRequest{Messages: history}
response, err := gemini15pro.Generate(context.Background(), &request, nil)

जब आपको कोई जवाब मिले, तो उसे इतिहास में जोड़ें:

history = append(history, response.Candidates[0].Message)

इस इतिहास को क्रम से लगाया जा सकता है और इसे किसी डेटाबेस या सेशन स्टोरेज में सेव किया जा सकता है. उपयोगकर्ता के बाद के अनुरोधों के लिए, कॉल करने से पहले उन्हें इतिहास में जोड़ें Generate():

history = append(history, &ai.Message{
  Content: []*ai.Part{ai.NewTextPart(prompt)},
  Role:    ai.RoleUser,
})

request = ai.GenerateRequest{Messages: history}
response, err = gemini15pro.Generate(ctx, &request, nil)

अगर इस्तेमाल किया जा रहा मॉडल, सिस्टम की भूमिका के साथ काम करता है, तो आपके पास इतिहास देखें:

शुरू करें

history = []*ai.Message{{
  	Content: []*ai.Part{ai.NewTextPart("Talk like a pirate.")},
  	Role:    ai.RoleSystem,
  }}