Configure Agent Output Language

Set a fixed reply language for an editable agent in your workspace, or clear the setting so replies follow the conversation language, and read back the updated metadata to confirm.

Task flow

Read current agent configuration and metadata
                     │
                     ▼
Set or clear metadata.output_language
                     │
                     ▼
Patch metadata and read back to verify

Prerequisites

  1. Complete the endpoint, personal access token, and workspace setup in Use the SDK.

  2. Obtain an editable agent ID (AGENT_ID) in the current workspace via Discover and Select Agents (or workspace.agents().list()).

  3. Choose a language code (OUTPUT_LANGUAGE), such as zh-CN, zh-TW, en-US, or ja-JP.

export AGENT_ID='<editable-agent-id>'
export OUTPUT_LANGUAGE='zh-CN'

Set a fixed output language

Read the current agent object, copy its existing metadata map, set output_language, submit the update via resource_patch (ResourcePatch in Go), and read back the agent to verify the saved value.

import os

import moi_product_sdk as sdk

client = sdk.new_with_personal_access_token(
    os.environ["PRODUCT_API_BASE_URL"],
    os.environ["PRODUCT_API_KEY"],
)
service = client.workspace(os.environ["WORKSPACE_ID"]).agents()
agent_id = os.environ["AGENT_ID"]
language = os.environ["OUTPUT_LANGUAGE"]

current = service.resource_get("agents", "/" + agent_id)
if current.get("id") != agent_id:
    raise RuntimeError("Agent identity does not match")

metadata = dict(current.get("metadata") or {})
metadata["output_language"] = language
service.resource_patch("agents", "/" + agent_id, {"metadata": metadata})

updated = service.resource_get("agents", "/" + agent_id)
actual = (updated.get("metadata") or {}).get("output_language")
if updated.get("id") != agent_id or actual != language:
    raise RuntimeError("Saved output language does not match")
print("agent id:", updated["id"])
print("output language:", actual)
package main

import (
	"context"
	"fmt"
	"log"
	"os"

	sdk "github.com/matrixorigin/matrixflow/sdk/go-sdk"
)

func main() {
	ctx := context.Background()
	client, err := sdk.NewWithPersonalAccessToken(
		os.Getenv("PRODUCT_API_BASE_URL"),
		os.Getenv("PRODUCT_API_KEY"),
	)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	workspace, err := client.Workspace(os.Getenv("WORKSPACE_ID"))
	if err != nil {
		log.Fatal(err)
	}
	service := workspace.Agents()
	agentID := os.Getenv("AGENT_ID")
	language := os.Getenv("OUTPUT_LANGUAGE")
	if language == "" {
		log.Fatal("set OUTPUT_LANGUAGE to a non-empty language code")
	}

	current, err := service.ResourceGet(ctx, "agents", "/"+agentID)
	if err != nil {
		log.Fatal(err)
	}
	agent, ok := current.Value.(map[string]any)
	if !ok || agent["id"] != agentID {
		log.Fatal("agent identity does not match")
	}

	metadata, _ := agent["metadata"].(map[string]any)
	if metadata == nil {
		metadata = map[string]any{}
	}
	metadata["output_language"] = language
	if _, err := service.ResourcePatch(ctx, "agents", "/"+agentID, map[string]any{"metadata": metadata}); err != nil {
		log.Fatal(err)
	}

	result, err := service.ResourceGet(ctx, "agents", "/"+agentID)
	if err != nil {
		log.Fatal(err)
	}
	updated, ok := result.Value.(map[string]any)
	if !ok || updated["id"] != agentID {
		log.Fatal("agent identity does not match")
	}
	saved, _ := updated["metadata"].(map[string]any)
	if saved["output_language"] != language {
		log.Fatal("saved output language does not match")
	}
	fmt.Println("agent id:", agentID)
	fmt.Println("output language:", saved["output_language"])
}

Follow the conversation language

To return the agent to following the input language of each conversation, continue from the previous setup by reading the latest metadata, setting output_language to an empty string "", and patching the agent:

current = service.resource_get("agents", "/" + agent_id)
metadata = dict(current.get("metadata") or {})
metadata["output_language"] = ""
service.resource_patch("agents", "/" + agent_id, {"metadata": metadata})

updated = service.resource_get("agents", "/" + agent_id)
actual = (updated.get("metadata") or {}).get("output_language", "")
if actual != "":
    raise RuntimeError("Output language was not cleared")
print("output language: follow conversation")
current, err = service.ResourceGet(ctx, "agents", "/"+agentID)
if err != nil {
	log.Fatal(err)
}
agent, _ = current.Value.(map[string]any)
metadata, _ = agent["metadata"].(map[string]any)
if metadata == nil {
	metadata = map[string]any{}
}
metadata["output_language"] = ""
if _, err := service.ResourcePatch(ctx, "agents", "/"+agentID, map[string]any{"metadata": metadata}); err != nil {
	log.Fatal(err)
}

result, err = service.ResourceGet(ctx, "agents", "/"+agentID)
if err != nil {
	log.Fatal(err)
}
updated, _ = result.Value.(map[string]any)
saved, _ = updated["metadata"].(map[string]any)
if saved["output_language"] != "" && saved["output_language"] != nil {
	log.Fatal("output language was not cleared")
}
fmt.Println("output language: follow conversation")

Limitations and notes

  • Output language is stored under metadata.output_language on the agent object. Because metadata is updated as an object map, always read and retain unrelated keys before patching; if multiple maintainers edit the same agent, refresh the latest object right before saving.

  • Agent output language is independent of user account UI language. Changes apply to new conversations, while existing historical replies remain unchanged.

Next steps

Last updated on