docs(eino): Standardize terminology to use 'Go' instead of 'Golang' (#1454)

Author: hycen6

content/en/docs/eino/_index.md

@@ -1,5 +1,5 @@
 ---
-Description: Eino is an AI application development framework based on Golang
+Description: Eino is an AI application development framework based on Go
 date: "2025-02-21"
 lastmod: ""
 linktitle: Eino
@@ -19,7 +19,7 @@ weight: 6
 > 💡
 > Eino：An AI  Application Development Framework Built with Go
 
-Eino aims to provide an AI  application development framework built with Go. Eino refers to many excellent AI application development frameworks in the open-source community, such as LangChain, LangGraph, LlamaIndex, etc., and provides an AI application development framework that is more in line with the programming habits of Golang.
+Eino aims to provide an AI  application development framework built with Go. Eino refers to many excellent AI application development frameworks in the open-source community, such as LangChain, LangGraph, LlamaIndex, etc., and provides an AI application development framework that is more in line with the programming habits of Go.
 
 Eino provides rich capabilities such as **atomic components**, **integrated components**, **component orchestration**, and **aspect extension** that assist in AI application development, which can help developers more simply and conveniently develop AI applications with a clear architecture, easy maintenance, and high availability.
 

content/en/docs/eino/core_modules/chain_and_graph_orchestration/_index.md

@@ -45,7 +45,7 @@ Specifically, the following features are implemented:
   - For more details, refer to: [Eino: Callback Manual](/docs/eino/core_modules/chain_and_graph_orchestration/callback_manual)
 - Provides a call option mechanism, **extensibility** is the most fundamental requirement of the system in rapid iterations.
   - For more details, refer to: [Eino: CallOption capabilities and specification](/docs/eino/core_modules/chain_and_graph_orchestration/call_option_capabilities)
-- Provides an enhanced "type alignment" development method, reducing the mental burden on developers and leveraging Golang's **type safety** features.
+- Provides an enhanced "type alignment" development method, reducing the mental burden on developers and leveraging Go's **type safety** features.
   - For more details, refer to: [Eino: The design concept of orchestration](/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles)
 - Provides an **"automated stream conversion"** capability, removing "stream" from the "source of complexity ranking" in the orchestration system.
   - For more details, refer to: [Eino Points of Streaming Orchestration](/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials)

content/en/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles.md

@@ -9,19 +9,19 @@ weight: 2
 
 In the LLM application orchestration solutions, the most popular ones are langchain and langgraph, which officially provide SDKs for Python and TypeScript. These two languages are known for their flexibility, which brings great convenience to SDK development but also causes significant confusion and cognitive burden for SDK users.
 
-As an extremely simple programming language, Golang's defined `static types` are one of the key reasons why it remains straightforward, and Eino maintains this critical characteristic: `defined types` + `compile-time type checking`.
+As an extremely simple programming language, Go's defined `static types` are one of the key reasons why it remains straightforward, and Eino maintains this critical characteristic: `defined types` + `compile-time type checking`.
 
 ## Basic Principle of `Type Alignment` in Upstream and Downstream
 
 The most fundamental orchestration method in eino is the graph, along with the simplified wrapped chain. Regardless of the orchestration method, it essentially consists of `logical nodes` + `upstream and downstream relationships`. At runtime, the product of the orchestration starts from one logical node and then proceeds to run the next node that is connected to the current node.
 
 This entails a basic assumption: **the output value of the previous node can serve as the input value for the next node.**
 
-In Golang, there are two basic approaches to achieving this assumption:
+In Go, there are two basic approaches to achieving this assumption:
 
 1. Convert the input and output of different nodes into a more generalized type, such as `any` or `map[string]any`.
    1. Adopting the approach to generalize into any, but the corresponding cost is that developers need to explicitly convert it into a specific type when writing code to use it. This significantly increases the mental burden on developers, hence this approach was ultimately abandoned.
-   2. The langchain approach can be seen as passing `map[string]any` throughout the process, where each logical node retrieves the corresponding value with the corresponding key based on its needs. In langchaingo's implementation, this approach is adopted. However, in Golang, they still need to be used with `type assertions`. This approach still imposes a significant mental burden on the developer.
+   2. The langchain approach can be seen as passing `map[string]any` throughout the process, where each logical node retrieves the corresponding value with the corresponding key based on its needs. In langchaingo's implementation, this approach is adopted. However, in Go, they still need to be used with `type assertions`. This approach still imposes a significant mental burden on the developer.
 2. Keep the input and output types of each node as expected by the developer, ensuring type consistency between upstream and downstream during the Compile phase.
 
 Approach 2 is the final approach selected by eino. This approach is the easiest to understand during orchestration. The whole process is like `building blocks`, where the protruding and recessed parts of each block have their own specifications, and only matching specifications can form upstream and downstream relationships.

content/en/docs/eino/core_modules/components/chat_template_guide.md

@@ -101,7 +101,7 @@ template := prompt.FromMessages(schema.FString,
 variables := map[string]any{
   "role": "professional assistant",
   "task": "write a poem",
-  "history_key": []*schema.Message{{Role: schema.User, Content: "what is golang?"}, {Role: schema.Assistant, Content: "golang is xxx"}},
+  "history_key": []*schema.Message{{Role: schema.User, Content: "what is Go?"}, {Role: schema.Assistant, Content: "Go is xxx"}},
 }
 
 // Format template

content/en/docs/eino/core_modules/flow_integration_components/react_agent_manual.md

@@ -206,7 +206,7 @@ func main() {
         MessageModifier: func(ctx context.Context, input []*schema.Message) []*schema.Message {
             res := make([]*schema.Message, 0, len(input)+1)
 
-            res = append(res, schema.SystemMessage("You are an expert golang developer."))
+            res = append(res, schema.SystemMessage("You are an expert Go developer."))
             res = append(res, input...)
             return res
         },
@@ -215,7 +215,7 @@ func main() {
     agent.Generate(ctx, []*schema.Message{schema.UserMessage("Write a hello world code")})
     // The actual input to the ChatModel would be
     // []*schema.Message{
-    //    {Role: schema.System, Content: "You are an expert golang developer."},
+    //    {Role: schema.System, Content: "You are an expert Go developer."},
     //    {Role: schema.Human, Content: "Write a hello world code"}
     //}
 }
@@ -329,7 +329,7 @@ agent, _ := react.NewAgent(...)
 
 var outMessage *schema.Message
 outMessage, err = agent.Generate(ctx, []*schema.Message{
-    schema.UserMessage("Write a hello world program in golang"),
+    schema.UserMessage("Write a hello world program in Go"),
 })
 ```
 
@@ -340,7 +340,7 @@ agent, _ := react.NewAgent(...)
 
 var msgReader *schema.StreamReader[*schema.Message]
 msgReader, err = agent.Stream(ctx, []*schema.Message{
-    schema.UserMessage("Write a hello world program in golang"),
+    schema.UserMessage("Write a hello world program in Go"),
 })
 
 for {

content/en/docs/eino/ecosystem_integration/tool/tool_duckduckgo_search.md

@@ -80,7 +80,7 @@ func main() {
 
     // Create search request
     searchReq := &duckduckgo.SearchRequest{
-        Query: "Golang programming development",
+        Query: "Go programming development",
         Page:  1,
     }
 

content/en/docs/eino/ecosystem_integration/tool/tool_googlesearch.md

@@ -82,7 +82,7 @@ func main() {
 
     // prepare params
     req := googlesearch.SearchRequest{
-        Query: "Golang concurrent programming",
+        Query: "Go concurrent programming",
         Num:   3,
         Lang:  "en",
     }
@@ -123,7 +123,7 @@ func main() {
     // 2. Title: Concurrency — An Introduction to Programming in Go | Go Resources
     //    Link: https://www.golang-book.com/books/intro/10
     //    Desc:
-    // 3. Title: The Comprehensive Guide to Concurrency in Golang | by Brandon ...
+    // 3. Title: The Comprehensive Guide to Concurrency in Go | by Brandon ...
     //    Link: https://bwoff.medium.com/the-comprehensive-guide-to-concurrency-in-golang-aaa99f8bccf6
     //    Desc: Update (November 20, 2023) — This article has undergone a comprehensive revision for enhanced clarity and conciseness. I’ve streamlined the…
 
@@ -135,7 +135,7 @@ func main() {
 
 ```json
 {
-    "query": "Golang concurrent programming",
+    "query": "Go concurrent programming",
     "items": [
         {
             "link": "https://example.com/article1",

content/en/docs/eino/overview/_index.md

@@ -9,7 +9,7 @@ weight: 1
 
 ## Introduction
 
-**Eino['aino]** (pronounced similarly to "I know, hoping that the framework can achieve the vision of "I know") aims to be the ultimate LLM application development framework in Golang. Drawing inspiration from many excellent LLM application development frameworks in the open-source community such as LangChain & LlamaIndex, etc., as well as learning from cutting-edge research and real world applications, Eino offers an LLM application development framework that emphasizes simplicity, scalability, reliability and effectiveness that better aligns with Golang programming conventions.
+**Eino['aino]** (pronounced similarly to "I know, hoping that the framework can achieve the vision of "I know") aims to be the ultimate LLM application development framework in Go. Drawing inspiration from many excellent LLM application development frameworks in the open-source community such as LangChain & LlamaIndex, etc., as well as learning from cutting-edge research and real world applications, Eino offers an LLM application development framework that emphasizes simplicity, scalability, reliability and effectiveness that better aligns with Go programming conventions.
 
 What Eino provides are:
 

content/en/docs/eino/overview/eino_framework_structure.md

@@ -118,7 +118,7 @@ Complex streaming operation scenarios:
   - When copying streams, both consumption coordination and 'Close' coordination need to be considered. If any stream isn't properly closed, it may prevent resources from being properly released
 - Merging multiple streams into one stream
 
-To make the Stream API interface clearer and easier to use, it aligns with Golang's built-in io.Pipe() method definition.
+To make the Stream API interface clearer and easier to use, it aligns with Go's built-in io.Pipe() method definition.
 
 - API interface is defined as: `schema.Pipe[T any](cap int) (*StreamReader[T], *StreamWriter[T])`
   - where cap indicates the stream's buffer size, i.e., how many chunks the sender can send without blocking when there's no consumption

content/en/docs/eino/overview/eino_open_source.md

@@ -7,15 +7,15 @@ title: Large Language Model Application Development Framework — Eino is Now Op
 weight: 0
 ---
 
-Today, after more than six months of internal use and iteration at ByteDance, the Golang-based comprehensive LLM application development framework — Eino, has been officially open-sourced on CloudWeGo!
+Today, after more than six months of internal use and iteration at ByteDance, the Go-based comprehensive LLM application development framework — Eino, has been officially open-sourced on CloudWeGo!
 
 Based on clear "component" definitions, Eino provides powerful process "orchestration" covering the entire development lifecycle, aiming to help developers create the most sophisticated LLM applications in the shortest time possible.
 
 Have you ever felt this way: wanting to add LLM capabilities to your application but not knowing where to start in this relatively new field; wanting to stay at the forefront of research and apply the latest industry achievements, but using an application development framework that hasn't been updated for months; trying to understand Python code in your project, needing to repeatedly check context to confirm a variable or parameter type; unsure whether the model-generated results are good enough and hesitant to use them; needing to explore and learn additional tools for necessary aspects beyond development like debugging, tracing, and evaluation. If so, welcome to Eino! As a LLM application development framework aimed at covering the entire devops process, Eino has the following characteristics:
 
 - Stable core, simple and understandable API, clear onboarding path, and smooth learning curve.
 - Ultimate extensibility, highly active development work, long-term sustainability.
-- Based on strongly-typed Golang, readable code, easy maintenance, high reliability.
+- Based on strongly-typed Go, readable code, easy maintenance, high reliability.
 - Backed by extensive practical experience from ByteDance's core business lines.
 - Provides out-of-the-box supporting tools.
 
@@ -116,7 +116,7 @@ Behind these dozens of lines of code, Eino automatically handles several things:
 
 LLM-based software applications are in a rapid development phase, with new technologies, ideas, and practices constantly emerging. As application developers, we need to efficiently and reliably implement industry-consensus best practices while continuously learning and improving our understanding to comprehend the possibilities in this new field. Therefore, an excellent LLM application development framework needs to both **encapsulate the "unchanging" universal core elements** in the domain and **enable agile horizontal and vertical expansion** based on latest developments.
 
-On the other hand, current mainstream frameworks like LangChain and LlamaIndex are Python-based. While they can quickly implement diverse functionalities by leveraging Python's rich ecosystem, they also inherit issues like "weak type checking" and "high long-term maintenance costs" that come with Python being a dynamic language. As LLM applications rapidly enter large-scale online operation phase, the **high reliability** and **high maintainability** achieved through Golang as a strongly-typed language are becoming increasingly valuable.
+On the other hand, current mainstream frameworks like LangChain and LlamaIndex are Python-based. While they can quickly implement diverse functionalities by leveraging Python's rich ecosystem, they also inherit issues like "weak type checking" and "high long-term maintenance costs" that come with Python being a dynamic language. As LLM applications rapidly enter large-scale online operation phase, the **high reliability** and **high maintainability** achieved through Go as a strongly-typed language are becoming increasingly valuable.
 
 LLM-based application development is a relatively new field, sometimes requiring exploration and validation through practice. Leveraging ByteDance's high-frequency applications like Doubao and Douyin with their diverse scenarios, rapid iteration, and massive feedback, Eino has unique advantages in **practice-driven design**.
 
@@ -150,7 +150,7 @@ In summary, the Eino framework possesses comprehensive extensibility:
 
 ### High Reliability and Maintainability
 
-When writing Eino code in Golang, developers can fully utilize Golang's strong typing features to declare specific types for all components, Lambdas, and orchestration products. This is like drawing a precise map for the code, allowing developers to maintain and extend along clear paths. Even as the project scale grows and functionality continues to iterate, high maintainability can still be preserved.
+When writing Eino code in Go, developers can fully utilize Go's strong typing features to declare specific types for all components, Lambdas, and orchestration products. This is like drawing a precise map for the code, allowing developers to maintain and extend along clear paths. Even as the project scale grows and functionality continues to iterate, high maintainability can still be preserved.
 
 At the same time, Eino's orchestration capabilities also fully utilize the compile-time verification capabilities of the strong type system, exposing type matching issues at graph compilation time rather than runtime whenever possible. Early and clear exposure of type matching issues helps developers quickly locate and fix problems, reducing hard-to-diagnose failures and performance issues caused by type errors at runtime.