फ़्लो

फ़्लो, रैप किए गए फ़ंक्शन होते हैं. इनमें डायरेक्ट कॉल की तुलना में कुछ अतिरिक्त सुविधाएं होती हैं: ये स्ट्रीम किए जा सकते हैं, स्थानीय और रिमोट तौर पर कॉल किए जा सकते हैं, और पूरी तरह से निगरानी किए जा सकते हैं. Firebase Genkit, फ़्लो चलाने और डीबग करने के लिए, CLI और डेवलपर यूज़र इंटरफ़ेस (यूआई) टूल उपलब्ध कराता है.

फ़्लो तय करना

सबसे आसान तरीके से, फ़्लो सिर्फ़ किसी फ़ंक्शन को रैप करता है:

menuSuggestionFlow := genkit.DefineFlow(
	"menuSuggestionFlow",
	func(ctx context.Context, restaurantTheme string) (string, error) {
		suggestion := makeMenuItemSuggestion(restaurantTheme)
		return suggestion, nil
	})

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

मॉडल एपीआई को सीधे कॉल करने के मुकाबले, Genkit फ़्लो का एक अहम फ़ायदा यह है कि इनपुट और आउटपुट, दोनों के टाइप की सुरक्षा होती है. किसी फ़्लो के आर्ग्युमेंट और नतीजे के टाइप, सामान्य या स्ट्रक्चर्ड वैल्यू हो सकते हैं. Genkit, invopop/jsonschema का इस्तेमाल करके, इन वैल्यू के लिए JSON स्कीमा जनरेट करेगा.

यहां दिया गया फ़्लो, string को इनपुट के तौर पर लेता है और struct को आउटपुट के तौर पर देता है:

type MenuSuggestion struct {
	ItemName    string `json:"item_name"`
	Description string `json:"description"`
	Calories    int    `json:"calories"`
}

menuSuggestionFlow := genkit.DefineFlow(
	"menuSuggestionFlow",
	func(ctx context.Context, restaurantTheme string) (MenuSuggestion, error) {
		suggestion := makeStructuredMenuItemSuggestion(restaurantTheme)
		return suggestion, nil
	},
)

रनिंग फ़्लो

अपने कोड में फ़्लो चलाने के लिए:

suggestion, err := menuSuggestionFlow.Run(context.Background(), "French")

फ़्लो चलाने के लिए भी सीएलआई का इस्तेमाल किया जा सकता है:

genkit flow:run menuSuggestionFlow '"French"'

स्ट्रीम की गई

यहां वैल्यू स्ट्रीम कर सकने वाले फ़्लो का एक आसान उदाहरण दिया गया है:

// Types for illustrative purposes.
type InputType string
type OutputType string
type StreamType string

menuSuggestionFlow := genkit.DefineStreamingFlow(
	"menuSuggestionFlow",
	func(
		ctx context.Context,
		restaurantTheme InputType,
		callback func(context.Context, StreamType) error,
	) (OutputType, error) {
		var menu strings.Builder
		menuChunks := make(chan StreamType)
		go makeFullMenuSuggestion(restaurantTheme, menuChunks)
		for {
			chunk, ok := <-menuChunks
			if !ok {
				break
			}
			if callback != nil {
				callback(context.Background(), chunk)
			}
			menu.WriteString(string(chunk))
		}
		return OutputType(menu.String()), nil
	},
)

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

स्ट्रीमिंग मोड में फ़्लो को शुरू करने के लिए:

menuSuggestionFlow.Stream(
	context.Background(),
	"French",
)(func(sfv *genkit.StreamFlowValue[OutputType, StreamType], err error) bool {
	if err != nil {
		// handle err
		return false
	}
	if !sfv.Done {
		fmt.Print(sfv.Stream)
		return true
	} else {
		fmt.Print(sfv.Output)
		return false
	}
})

अगर फ़्लो में स्ट्रीमिंग लागू नहीं होती है, तो StreamFlow() की तरह ही काम करता है RunFlow().

फ़्लो स्ट्रीम करने के लिए भी, CLI का इस्तेमाल किया जा सकता है:

genkit flow:run menuSuggestionFlow '"French"' -s

फ़्लो डिप्लॉय करना

अगर आपको एचटीटीपी पर फ़्लो ऐक्सेस करना है, तो पहले उसे डिप्लॉय करें. Cloud Run और मिलती-जुलती सेवाओं का इस्तेमाल करके फ़्लो डिप्लॉय करने के लिए, अपने फ़्लो तय करें और फिर Init() को कॉल करें:

func main() {
	genkit.DefineFlow(
		"menuSuggestionFlow",
		func(ctx context.Context, restaurantTheme string) (string, error) {
			// ...
			return "", nil
		},
	)
	if err := genkit.Init(context.Background(), nil); err != nil {
		log.Fatal(err)
	}
}

Init, net/http सर्वर को शुरू करता है, जो आपके फ़्लो को एचटीटीपी एंडपॉइंट (उदाहरण के लिए, http://localhost:3400/menuSuggestionFlow) के तौर पर दिखाता है.

दूसरा पैरामीटर एक वैकल्पिक Options है, जो नीचे दी गई चीज़ों के बारे में बताता है:

• FlowAddr: सुनने के लिए पता और पोर्ट. अगर यह जानकारी नहीं दी जाती है, तो सर्वर, PORT एनवायरमेंट वैरिएबल में बताए गए पोर्ट पर सुनता है. अगर यह वैरिएबल खाली है, तो यह डिफ़ॉल्ट पोर्ट 3400 का इस्तेमाल करता है.
• Flows: कौनसे फ़्लो दिखाने हैं. अगर कोई वैल्यू नहीं दी गई है, तो Init आपके तय किए गए सभी फ़्लो दिखाता है.

अगर आपको अन्य एंडपॉइंट के तौर पर एक ही होस्ट और पोर्ट पर फ़्लो दिखाने हैं, तो FlowAddr को - पर सेट किया जा सकता है. इसके बजाय, अपने Genkit फ़्लो के लिए हैंडलर पाने के लिए NewFlowServeMux() को कॉल किया जा सकता है. इस हैंडलर को अपने अन्य रूट हैंडलर के साथ मल्टीप्लेक्स किया जा सकता है:

mainMux := http.NewServeMux()
mainMux.Handle("POST /flow/", http.StripPrefix("/flow/", genkit.NewFlowServeMux(nil)))

फ़्लो की निगरानी करने की सुविधा

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

genkit.DefineFlow(
	"menuSuggestionFlow",
	func(ctx context.Context, restaurantTheme string) (string, error) {
		themes, err := genkit.Run(ctx, "find-similar-themes", func() (string, error) {
			// ...
			return "", nil
		})

		// ...
		return themes, err
	})