फ़्लो

शुरू करें

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

शुरू करें

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

नीचे दिया गया फ़्लो, इनपुट के तौर पर 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")

शुरू करें

// 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 !sfv.Done {
      fmt.Print(sfv.Output)
      return true
  } else {
      return false
  }
})

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

शुरू करें

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 को - पर सेट कर सकता है. इसके बजाय, हैंडलर पाने के लिए NewFlowServeMux() को कॉल कर सकता है अपने Genkit फ़्लो के लिए, जिसे आप अपने दूसरे रूट हैंडलर के साथ मल्टीप्लेक्स कर सकते हैं:

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