API 개요

`class` `Agent`

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
model_name: <class 'str'>
temperature: <class 'float'>
system_message: <class 'str'>
tools: list[typing.Any]

`method` `step`

step(state: AgentState) → AgentState

에이전트의 단계를 한 번 실행합니다. 인수:

state: 환경의 현재 상태입니다.
action: 수행할 액션입니다. 반환값: 환경의 새 상태입니다.

`class` `AgentState`

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
history: list[typing.Any]

`class` `AnnotationSpec`

Pydantic Fields:

name: str | None
description: str | None
field_schema: dict[str, typing.Any]
unique_among_creators: <class 'bool'>
op_scope: list[str] | None

`클래스 메서드` `preprocess_field_schema`

preprocess_field_schema(data: Any) → Any

`클래스 메서드` `validate_field_schema`

validate_field_schema(schema: dict[str, Any]) → dict[str, Any]

`method` `value_is_valid`

value_is_valid(payload: Any) → bool

이 어노테이션 사양의 스키마에 따라 페이로드를 검증합니다. 인수:

payload: 스키마에 따라 검증할 데이터 반환값:
bool: 검증에 성공하면 True, 실패하면 False

`클래스` `Audio`

지원되는 형식(wav 또는 mp3)의 오디오 데이터를 나타내는 클래스입니다. 이 클래스는 오디오 데이터의 저장을 처리하며, 다양한 소스에서 데이터를 로드하고 파일로 내보내는 방법을 제공합니다. 속성:

format: 오디오 형식(현재 ‘wav’ 또는 ‘mp3’ 지원)
data: 바이트 형식의 원시 오디오 데이터

인수:

data: 오디오 데이터(바이트 또는 base64로 인코딩된 string)
format: 오디오 형식(‘wav’ 또는 ‘mp3’)
validate_base64: 입력 데이터의 base64 디코딩을 시도할지 여부 예외:
ValueError: 오디오 데이터가 비어 있거나 지원되지 않는 형식인 경우

`method` `init`

__init__(
    data: 'bytes',
    format: 'SUPPORTED_FORMATS_TYPE',
    validate_base64: 'bool' = True
) → None

`method` `export`

export(path: 'str | bytes | Path | PathLike') → None

오디오 데이터를 파일로 내보냅니다. 인수:

`클래스 메서드` `from_data`

from_data(data: 'str | bytes', format: 'str') → Self

원시 데이터와 지정된 형식으로 Audio 객체를 생성합니다.

path: 오디오 파일을 쓸 경로 인수:
data: 바이트 또는 base64로 인코딩된 string 형식의 오디오 데이터
format: 오디오 형식(‘wav’ 또는 ‘mp3’) 반환값:
Audio: 새 Audio 인스턴스

예외:

ValueError: 지원되지 않는 형식인 경우

`클래스 메서드` `from_path`

from_path(path: 'str | bytes | Path | PathLike') → Self

파일 경로에서 Audio 객체를 생성합니다. 인수:

path: 오디오 파일 경로(확장자는 .wav 또는 .mp3여야 함) 반환값:
Audio: 파일에서 로드한 새 Audio 인스턴스

예외:

ValueError: 파일이 존재하지 않거나 확장자가 지원되지 않는 경우

`class` `ClassifierMonitor`

여러 Scorer를 하나의 분류기로 병합하는 모니터입니다. 분류기 모니터는 동일한 모델을 대상으로 하는 여러 LLMAsAJudgeScorer의 프롬프트를 하나의 점수화 호출로 통합합니다. Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
sampling_rate: <class 'float'>
scorers: list[flow.scorer.Scorer]
op_names: list[typing.Union[typing.Literal['genai.turn_ended'], str]]
query: trace_server.interface.query.Query | None
is_traced: <class 'bool'>
active: <class 'bool'>
scorer_debounce_config: flow.monitor.ScorerDebounceConfig | None
prompt_header: str | None
prompt_footer: str | None

`method` `activate`

activate() → ObjectRef

모니터를 활성화합니다. 반환값: 모니터의 ref입니다.

`method` `deactivate`

deactivate() → ObjectRef

모니터를 비활성화합니다. 반환값: 모니터의 ref입니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `get_prompt_footer`

get_prompt_footer() → str

병합된 분류기 프롬프트 뒤에 추가할 텍스트입니다.

`method` `get_prompt_header`

get_prompt_header(op_name: str) → str

병합된 분류기 프롬프트 앞에 추가할 텍스트입니다.

`method` `model_post_init`

model_post_init(context: Any) → None

클라이언트를 사용할 수 있는 경우 생성 시점에 op_names를 정규화합니다. 게시에는 객체별 훅이 없으므로, activate() 없이 weave.publish(monitor)만 단독으로 호출하는 경우까지 처리할 수 있도록 여기에서 짧은 이름을 확장합니다. 게시하려는 사용자는 대개 이미 weave.init을 호출했으므로, 모니터를 생성하는 시점에는 클라이언트가 설정되어 있습니다. 단위 테스트, 검사, 워커에서 저장된 모니터를 역직렬화하는 경우 등 클라이언트 없이 생성이 이루어지는 사용 사례도 여럿 있습니다. get_weave_client()에 가드를 두었기 때문에 클라이언트 없이도 생성할 수 있습니다. 이 경우에는 정규화가 수행되지 않지만, 저장된 모니터는 이미 전체 ref를 가지고 있으므로 문제가 되지 않습니다. 다만 SDK를 사용할 때 정규화 없이 모니터가 생성되는 예외적인 경우가 있습니다. 사용자가 모니터를 생성한 후 weave.init을 호출하고, 그다음 모니터를 게시하는 경우입니다. 이때는 activate() 또는 deactivate()를 호출하여 문제를 우회할 수 있습니다.

`class` `Content`

다양한 소스의 콘텐츠를 표현하는 클래스로, 콘텐츠를 관련 메타데이터와 함께 통합된 바이트 기반 표현으로 변환합니다. 이 클래스는 다음 클래스 메서드 중 하나를 사용하여 인스턴스화해야 합니다.

from_path()
from_bytes()
from_text()
from_url()
from_base64()
from_data_url()

`method` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

직접 초기화는 비활성화되어 있습니다. 인스턴스를 생성하려면 Content.from_path()와 같은 클래스 메서드를 사용하세요. Pydantic Fields:

data: <class 'bytes'>
size: <class 'int'>
mimetype: <class 'str'>
digest: <class 'str'>
filename: <class 'str'>
content_type: typing.Literal['bytes', 'text', 'base64', 'file', 'url', 'data_url', 'data_url:base64', 'data_url:encoding', 'data_url:encoding:base64']
input_type: <class 'str'>
encoding: <class 'str'>
metadata: dict[str, typing.Any] | None
extension: str | None

`property` art

`property` ref

`방법` `as_string`

as_string() → str

데이터를 string으로 표시합니다. 바이트는 encoding 속성에 따라 디코딩됩니다. base64인 경우 데이터를 base64 바이트로 다시 인코딩한 다음 ASCII string으로 디코딩합니다. 반환값: str.

`클래스 메서드` `from_base64`

from_base64(
    b64_data: 'str | bytes',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None
) → Self

base64로 인코딩된 string 또는 바이트에서 Content를 초기화합니다.

`클래스 메서드` `from_bytes`

from_bytes(
    data: 'bytes',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → Self

원시 바이트로 Content를 초기화합니다.

`클래스 메서드` `from_data_url`

from_data_url(url: 'str', metadata: 'dict[str, Any] | None' = None) → Self

데이터 URL로부터 Content를 초기화합니다.

`클래스 메서드` `from_path`

from_path(
    path: 'str | Path',
    encoding: 'str' = 'utf-8',
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None
) → Self

로컬 파일 경로에서 Content를 초기화합니다.

`클래스 메서드` `from_text`

from_text(
    text: 'str',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → Self

텍스트 문자열로 Content를 초기화합니다.

`클래스 메서드` `from_url`

from_url(
    url: 'str',
    headers: 'dict[str, Any] | None' = None,
    timeout: 'int | None' = 30,
    metadata: 'dict[str, Any] | None' = None
) → Self

HTTP(S) URL에서 바이트를 가져와 Content를 초기화합니다. 콘텐츠를 다운로드하고 헤더, URL 경로, 데이터를 바탕으로 MIME 유형/확장자를 추론한 다음, 가져온 바이트로 Content 객체를 생성합니다.

`클래스 메서드` `model_validate`

model_validate(
    obj: 'Any',
    strict: 'bool | None' = None,
    from_attributes: 'bool | None' = None,
    context: 'dict[str, Any] | None' = None,
    extra: 'str | None' = None,
    by_alias: 'bool | None' = None,
    by_name: 'bool | None' = None
) → Self

dict에서 Content를 재구성할 수 있도록 model_validate를 재정의합니다.

`클래스 메서드` `model_validate_json`

model_validate_json(
    json_data: 'str | bytes | bytearray',
    strict: 'bool | None' = None,
    context: 'dict[str, Any] | None' = None,
    extra: 'str | None' = None,
    by_alias: 'bool | None' = None,
    by_name: 'bool | None' = None
) → Self

JSON에서 Content를 재구성할 수 있도록 model_validate_json을 재정의합니다.

`method` `open`

open() → bool

운영 체제의 기본 애플리케이션으로 파일을 엽니다. 이 메서드는 플랫폼별 메커니즘을 사용하여 파일 유형에 연결된 기본 애플리케이션으로 파일을 엽니다. 반환값:

bool: 파일을 성공적으로 열면 True, 그렇지 않으면 False입니다.

`method` `save`

save(dest: 'str | Path') → None

파일을 지정된 대상 경로로 복사합니다. 마지막으로 저장한 사본을 반영하도록 콘텐츠의 파일 이름과 경로를 업데이트합니다. 인수:

`method` `serialize_data`

serialize_data(data: 'bytes') → str

JSON 모드로 모델을 덤프할 때 사용됩니다.

`방법` `to_data_url`

to_data_url(use_base64: 'bool' = True) → str

콘텐츠에서 데이터 URL을 생성합니다.

dest: 파일을 복사할 대상 경로입니다(string 또는 pathlib.Path). 대상 경로는 파일 또는 디렉터리일 수 있습니다. dest에 파일 확장자(예: .txt)가 없으면 대상을 디렉터리로 간주합니다. 인수:
use_base64: True이면 데이터를 base64로 인코딩합니다. 그렇지 않으면 퍼센트 인코딩합니다. 기본값은 True입니다. 반환값: 데이터 URL string입니다.

`class` `Conversation`

대화입니다. conversation_id를 기준으로 턴을 그룹화합니다(span은 생성하지 않음). continue_parent_trace는 이 대화가 생성하는 턴의 트레이스 격리 방식을 제어합니다. 기본값 False로 두면 각 턴이 자체 OTel 트레이스를 시작하며, 이는 독립형 Agents 탭 뷰에 적합합니다. 애플리케이션에 에이전트 호출을 포함해야 하는 외부 트레이스(예: fastapi로 계측된 요청)가 있다면 True로 설정하세요. Pydantic Fields:

conversation_id: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
include_content: <class 'bool'>
continue_parent_trace: <class 'bool'>
attributes: dict[str, typing.Any]

`method` `end`

end() → None

`method` `model_post_init`

model_post_init(context: 'Any') → None

`method` `start_turn`

start_turn(
    user_message: 'str' = '',
    model: 'str' = '',
    agent_name: 'str' = '',
    agent_id: 'str' = '',
    agent_description: 'str' = '',
    agent_version: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → Turn

새 turn을 생성합니다. 이전 turn이 아직 열려 있으면 자동으로 종료합니다. _current_turn contextvar를 설정하므로, context manager 사용 여부와 관계없이 get_current_turn()으로 turn을 확인할 수 있습니다. agent_name / model / agent_id / agent_description / agent_version은 비워 두면 각각 대화의 기본값이 사용되며, continue_parent_trace는 상속됩니다. 이 값들은 나중에 turn.record(...)로 재정의할 수 있습니다. system_instructions(에이전트의 system 프롬프트)는 turn의 invoke_agent span에 포함됩니다. start_llm과 마찬가지로, 반환된 Turn에 속성을 할당하여 나중에 설정할 수도 있습니다.

`class` `Dataset`

손쉽게 저장하고 버전을 자동으로 관리할 수 있는 데이터셋 객체입니다. 예시:

# 데이터셋 생성
dataset = Dataset(name='grammar', rows=[
     {'id': '0', 'sentence': "He no likes ice cream.", 'correction': "He doesn't like ice cream."},
     {'id': '1', 'sentence': "She goed to the store.", 'correction': "She went to the store."},
     {'id': '2', 'sentence': "They plays video games all day.", 'correction': "They play video games all day."}
])

# 데이터셋 게시
weave.publish(dataset)

# 데이터셋 조회
dataset_ref = weave.ref('grammar').get()

# 특정 예시에 액세스
example_label = dataset_ref.rows[2]['sentence']

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
rows: trace.table.Table | trace.vals.WeaveTable

`method` `add_rows`

add_rows(rows: Iterable[dict]) → Dataset

기존 데이터셋에 행을 추가하여 새 데이터셋 버전을 만듭니다. 전체 데이터셋을 메모리에 로드하지 않고도 대규모 데이터셋에 예시를 추가할 수 있어 유용합니다. 인수:

rows: 데이터셋에 추가할 행입니다. 반환값: 업데이트된 데이터셋입니다.

`클래스 메서드` `convert_to_table`

convert_to_table(rows: Any) → Table | WeaveTable

`클래스 메서드` `from_calls`

from_calls(calls: Iterable[Call]) → Self

`클래스 메서드` `from_hf`

from_hf(hf_dataset: 'HFDataset | HFDatasetDict') → Self

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`클래스 메서드` `from_pandas`

from_pandas(df: 'DataFrame') → Self

`method` `select`

select(indices: Iterable[int]) → Self

제공된 인덱스를 기준으로 데이터셋에서 행을 선택합니다. 인수:

indices: 선택할 행을 지정하는 정수 인덱스로 구성된 iterable입니다. 반환값: 선택한 행만 포함하는 새 Dataset 객체입니다.

`method` `to_hf`

to_hf() → HFDataset

`method` `to_pandas`

to_pandas() → DataFrame

`클래스` `EasyPrompt`

`method` `init`

__init__(
    content: str | dict | list | None = None,
    role: str | None = None,
    dedent: bool = False,
    **kwargs: Any
) → None

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
data: <class 'list'>
config: <class 'dict'>
requirements: <class 'dict'>

`property` as_str

모든 메시지를 하나의 string으로 결합합니다.

`property` is_bound

`property` messages

`property` placeholders

`property` system_message

모든 메시지를 하나의 system 프롬프트 메시지로 결합합니다.

`property` system_prompt

모든 메시지를 하나의 system 프롬프트 객체로 결합합니다.

`property` unbound_placeholders

`method` `append`

append(item: Any, role: str | None = None, dedent: bool = False) → None

`method` `as_dict`

as_dict() → dict[str, Any]

`method` `as_pydantic_dict`

as_pydantic_dict() → dict[str, Any]

`method` `bind`

bind(*args: Any, **kwargs: Any) → Prompt

`method` `bind_rows`

bind_rows(dataset: list[dict] | Any) → list['Prompt']

`method` `config_table`

config_table(title: str | None = None) → Table

`method` `configure`

configure(config: dict | None = None, **kwargs: Any) → Prompt

`method` `dump`

dump(fp: <class 'IO'>) → None

`method` `dump_file`

dump_file(filepath: str | Path) → None

`method` `format`

format(**kwargs: Any) → Any

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`클래스 메서드` `load`

load(fp: <class 'IO'>) → Self

`클래스 메서드` `load_file`

load_file(filepath: str | Path) → Self

`method` `messages_table`

messages_table(title: str | None = None) → Table

`method` `print`

print() → str

`method` `publish`

publish(
    name: str | None = None,
    tags: list[str] | None = None,
    aliases: list[str] | None = None
) → ObjectRef

`method` `require`

require(param_name: str, **kwargs: Any) → Prompt

`method` `run`

run() → Any

`method` `validate_requirement`

validate_requirement(key: str, value: Any) → list

`method` `validate_requirements`

validate_requirements(values: dict[str, Any]) → list

`method` `values_table`

values_table(title: str | None = None) → Table

`class` `Evaluation`

Scorer 집합과 데이터셋으로 구성된 평가를 설정합니다. evaluation.evaluate(model)을 호출하면 데이터셋의 열 이름과 model.predict의 인수 이름을 매칭하여 데이터셋의 행을 모델에 전달합니다. 그런 다음 모든 Scorer를 호출하고 결과를 weave에 저장합니다. 데이터셋의 행을 전처리하려면 preprocess_model_input에 함수를 전달하면 됩니다. 예시:

# 예시를 수집합니다
examples = [
     {"question": "What is the capital of France?", "expected": "Paris"},
     {"question": "Who wrote 'To Kill a Mockingbird'?", "expected": "Harper Lee"},
     {"question": "What is the square root of 64?", "expected": "8"},
]

# 원하는 맞춤형 점수화 함수를 정의합니다
@weave.op
def match_score1(expected: str, model_output: dict) -> dict:
     # 여기에서 모델 출력을 점수화하는 로직을 정의합니다
     return {'match': expected == model_output['generated_text']}

@weave.op
def function_to_evaluate(question: str):
     # 여기에서 LLM Call을 추가하고 출력을 반환합니다
     return  {'generated_text': 'Paris'}

# 점수화 함수로 예시를 점수화합니다
evaluation = Evaluation(
     dataset=examples, scorers=[match_score1]
)

# 평가 추적을 시작합니다
weave.init('intro-example')
# 평가를 실행합니다
asyncio.run(evaluation.evaluate(function_to_evaluate))

Pydantic 필드:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
dataset: <class 'dataset.dataset.Dataset'>
scorers: list[typing.Annotated[trace.op_protocol.Op | flow.scorer.Scorer, BeforeValidator(func=<function cast_to_scorer at 0x7f136d430d60>, json_schema_input_type=PydanticUndefined)]] | None
preprocess_model_input: collections.abc.Callable[[dict], dict] | None
trials: <class 'int'>
metadata: dict[str, typing.Any] | None
evaluation_name: str | collections.abc.Callable[trace.call.Call, str] | None

`method` `evaluate`

evaluate(model: Op | Model) → dict

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `get_eval_results`

get_eval_results(model: Op | Model) → EvaluationResults

`method` `get_evaluate_calls`

get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]

이 Evaluation 객체를 사용한 모든 평가 Call을 조회합니다. 하나의 평가에 대해 여러 평가 Call이 존재할 수 있으므로(예: 동일한 평가를 여러 번 실행한 경우) 이 메서드는 단일 Call이 아닌 CallsIter를 반환합니다. 반환값:

CallsIter: 평가 실행을 나타내는 Call 객체의 이터레이터입니다.

예외:

ValueError: 평가에 ref가 없는 경우(아직 저장 또는 실행되지 않은 경우).

예시:

evaluation = Evaluation(dataset=examples, scorers=[scorer])
await evaluation.evaluate(model)  # 먼저 평가 실행
calls = evaluation.get_evaluate_calls()
for call in calls:
     print(f"Evaluation run: {call.id} at {call.started_at}")

`method` `get_score_calls`

get_score_calls() → dict[str, list[Call]]

각 평가 run의 Scorer Call을 트레이스 ID별로 그룹화하여 가져옵니다. 반환값:

dict[str, list[Call]]: 트레이스 ID를 Scorer Call 객체 목록에 매핑하는 딕셔너리입니다. 각 트레이스 ID는 하나의 평가 run에 해당하며, 목록에는 해당 run에서 실행된 모든 Scorer Call이 포함됩니다.

예시:

evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
score_calls = evaluation.get_score_calls()
for trace_id, calls in score_calls.items():
     print(f"Trace {trace_id}: {len(calls)} scorer calls")
     for call in calls:
         scorer_name = call.summary.get("weave", {}).get("trace_name")
         print(f"  Scorer: {scorer_name}, Output: {call.output}")

`method` `get_scores`

get_scores() → dict[str, dict[str, list[Any]]]

평가 run에서 Scorer 출력을 추출하고 정리합니다. 반환값:

dict[str, dict[str, list[Any]]]: 다음과 같은 구조의 중첩 딕셔너리입니다.
- 첫 번째 수준의 키는 트레이스 ID(평가 run)입니다.
- 두 번째 수준의 키는 Scorer 이름입니다.
- 값은 해당 run과 Scorer의 출력 목록입니다.

예시:

evaluation = Evaluation(dataset=examples, scorers=[accuracy_scorer, f1_scorer])
await evaluation.evaluate(model)
scores = evaluation.get_scores()
# 트레이스 및 Scorer별 점수에 액세스
for trace_id, trace_scores in scores.items():
         print(f"Evaluation run {trace_id}:")
         for scorer_name, outputs in trace_scores.items():
             print(f"  {scorer_name}: {outputs}")

예상 출력:

{
     "trace_123": {
     "accuracy_scorer": [{"accuracy": 0.85}],
     "f1_scorer": [{"f1": 0.78}]
     }
}

`method` `model_post_init`

model_post_init(context: Any) → None

`method` `predict_and_score`

predict_and_score(model: Op | Model, example: dict) → dict

`method` `summarize`

summarize(eval_table: EvaluationResults) → dict

`class` `EvaluationLogger`

이 클래스는 평가를 로깅하기 위한 명령형 인터페이스를 제공합니다. 평가는 log_prediction 메서드로 첫 번째 예측을 로깅하면 자동으로 시작되고, log_summary 메서드를 호출하면 종료됩니다. 예측을 로깅할 때마다 ScoreLogger 객체가 반환됩니다. 이 객체를 사용하면 해당 예측의 점수와 메타데이터를 로깅할 수 있습니다. 자세한 내용은 ScoreLogger 클래스를 참조하세요. 기본 사용법 - 입력과 출력을 포함한 예측을 직접 로깅합니다.

ev = EvaluationLogger()

# 입력/출력을 이미 알고 있는 예측 로깅
pred = ev.log_prediction(inputs={'q': 'Hello'}, outputs={'a': 'Hi there!'})
pred.log_score("correctness", 0.9)

# 평가 종료
ev.log_summary({"avg_score": 0.9})

고급 사용법 - 동적 출력과 중첩된 오퍼레이션에는 컨텍스트 관리자를 사용하세요.

ev = EvaluationLogger()

# 중첩된 오퍼레이션을 캡처하려면 컨텍스트 매니저를 사용하세요
with ev.log_prediction(inputs={'q': 'Hello'}) as pred:
     # 이 블록에서 실행되는 모든 오퍼레이션(예: LLM Call)은 자동으로
     # predict Call의 하위 항목이 됩니다
     response = your_llm_call(...)
     pred.output = response.content
     pred.log_score("correctness", 0.9)

# 평가 종료
ev.log_summary({"avg_score": 0.9})

`method` `init`

__init__(
    name: 'str | None' = None,
    model: 'Model | dict | str | None' = None,
    dataset: 'Dataset | list[dict] | str | None' = None,
    eval_attributes: 'dict[str, Any] | None' = None,
    scorers: 'list[str] | None' = None
) → None

`property` attributes

`property` ui_url

`method` `fail`

fail(exception: 'BaseException') → None

예외를 지정해 평가를 실패로 처리하는 편의 메서드입니다.

`method` `finish`

finish(exception: 'BaseException | None' = None) → None

요약을 로깅하지 않고 평가 리소스를 명시적으로 정리합니다. 모든 예측 Call과 메인 평가 Call이 확정(finalized) 상태가 되도록 합니다. 로거를 컨텍스트 관리자로 사용하면 이 메서드가 자동으로 호출됩니다.

`method` `log_example`

log_example(
    inputs: 'dict[str, Any]',
    output: 'Any',
    scores: 'dict[str, ScoreType]'
) → None

입력, 출력, 점수를 모두 포함한 전체 예제를 로깅합니다. 모든 데이터가 미리 준비되어 있을 때 log_prediction과 log_score를 한 번에 수행할 수 있는 편의 메서드입니다. 인수:

inputs: 예측에 사용할 입력 데이터
output: 출력 값
scores: Scorer 이름과 점수 값을 매핑한 딕셔너리 예시:

ev = EvaluationLogger()
ev.log_example(
    inputs={'q': 'What is 2+2?'},
    output='4',
    scores={'correctness': 1.0, 'fluency': 0.9}
)

`method` `log_prediction`

log_prediction(inputs: 'dict[str, Any]', output: 'Any' = None) → ScoreLogger

Evaluation에 예측을 로깅합니다. 직접 사용하거나 컨텍스트 관리자로 사용할 수 있는 ScoreLogger를 반환합니다. 인수:

inputs: 예측의 입력 데이터
output: 출력 값입니다. 기본값은 None입니다. 나중에 pred.output으로 설정할 수 있습니다. 반환값: 점수를 로깅하고 필요한 경우 예측을 종료하는 데 사용하는 ScoreLogger입니다.

예시(직접 사용):

pred = ev.log_prediction({'q': ’…’}, output=“answer”) pred.log_score(“correctness”, 0.9) pred.finish()

예시(컨텍스트 관리자):

with ev.log_prediction({'q': ’…’}) as pred: response = model(…) pred.output = response pred.log_score(“correctness”, 0.9) # 블록을 벗어나면 finish()가 자동으로 호출됩니다

`method` `log_summary`

log_summary(summary: 'dict | None' = None, auto_summarize: 'bool' = True) → None

요약 dict를 Evaluation에 로깅합니다. 이 메서드는 요약을 계산하고 summarize op를 호출한 다음 평가를 종료합니다. 따라서 이후에는 예측이나 점수를 더 이상 로깅할 수 없습니다.

`method` `set_view`

set_view(
    name: 'str',
    content: 'Content | str',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → None

평가의 기본 call 요약에서 weave.views 아래에 뷰를 첨부합니다. 제공된 content를 프로젝트에 객체로 저장하고, 평가의 evaluate call에 대해 해당 레퍼런스 URI를 summary.weave.views.<name> 아래에 기록합니다. string 입력은 제공된 확장자 또는 MIME 유형을 적용해 Content.from_text로 텍스트 content로 래핑됩니다. 인수:

name: 표시할 뷰 이름입니다. summary.weave.views 아래의 키로 사용됩니다.
content: 직렬화할 weave.Content 인스턴스 또는 string입니다.
extension: string content 입력에 사용할 파일 확장자입니다(선택).
mimetype: string content 입력에 사용할 MIME 유형입니다(선택).
metadata: 새로 생성된 Content에 첨부할 메타데이터입니다(선택).
encoding: string content 입력에 사용할 텍스트 인코딩입니다. 반환값: None

예시: import weave

ev = weave.EvaluationLogger() ev.set_view(“report”, ”# Report”, extension=“md”)

`class` `File`

경로, MIME 유형, 크기 정보를 포함하는 파일을 나타내는 클래스입니다.

`method` `init`

__init__(path: 'str | Path', mimetype: 'str | None' = None)

File 객체를 초기화합니다. 인수:

`property` filename

파일 이름을 조회합니다.

path: 파일 경로(string 또는 pathlib.Path)
mimetype: 파일의 MIME 유형(선택) - 지정하지 않으면 확장자로부터 추론됩니다 반환값:
str: 디렉터리 경로를 제외한 파일 이름입니다.

`method` `open`

open() → bool

bool: 파일을 성공적으로 열었으면 True, 그렇지 않으면 False입니다.

`method` `save`

save(dest: 'str | Path') → None

파일을 지정된 대상 경로에 복사합니다. 인수:

`class` `LLM`

단일 LLM API 호출을 나타냅니다. chat OTel span에 매핑됩니다.

dest: 파일을 복사할 대상 경로(string 또는 pathlib.Path)입니다. 대상 경로는 파일 또는 디렉터리일 수 있습니다. Pydantic 필드:
model: <class 'str'>
provider_name: <class 'str'>
response_id: <class 'str'>
response_model: <class 'str'>
output_type: <class 'str'>
system_instructions: list[str]
usage: <class 'conversation.types.Usage'>
reasoning: <class 'conversation.types.Reasoning'>
finish_reasons: list[str]
input_messages: list[conversation.types.Message]
output_messages: list[conversation.types.Message]
media_attachments: list[conversation.types.MediaAttachment]
request_temperature: float | None
request_max_tokens: int | None
request_top_p: float | None
request_frequency_penalty: float | None
request_presence_penalty: float | None
request_seed: int | None
request_stop_sequences: list[str]
request_choice_count: int | None
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

이 span 내의 특정 시점에 OTel span 이벤트를 기록합니다. .. deprecated: ``` 이 데이터는 대신 set_attributes로 기록하세요. OpenTelemetry는 Span Event API(Span.add_event)를 단계적으로 사용 중단하고 있습니다. add_event는 계속 작동하며 기존 span 이벤트 데이터도 그대로 유효합니다. 자세한 내용은 https://opentelemetry.io/blog/2026/deprecating-span-events/ 를 참조하세요.

마커 / 라이프사이클 데이터에 사용합니다. 권한 프롬프트(예: ``weave.permission_request``), 라이프사이클 상태 전환(예: ``spawned`` / ``streaming`` / ``finished``), 또는 span의 수명 중 특정 시점에 발생하는 맞춤형 마일스톤 등이 여기에 해당합니다(span 전체에 적용되는 속성인 attribute와는 다릅니다). 

span 시작과 종료 사이(``with`` 블록 내부)에서 호출해야 합니다. 이 범위 밖에서 호출하면 아무 작업도 수행되지 않으며 경고가 로깅됩니다. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L462" />

### <kbd>method</kbd> `attach_media`

```python
attach_media(
    content: 'bytes | str' = '',
    uri: 'str' = '',
    file_id: 'str' = '',
    mime_type: 'str' = '',
    modality: 'str' = ''
) → LLM

이 LLM Call에 미디어를 첨부합니다. 제공된 데이터로 Content 객체를 생성하고 이를 게시하여 weave:// ref를 얻은 다음, 해당 ref만 저장합니다. content, uri, file_id 중 정확히 하나를 제공해야 합니다. 게시(미디어 업로드) 작업은 전용 백그라운드 스레드에서 실행되므로, 호출자를 차단하지 않고 호출이 즉시 반환됩니다. 첨부 항목마다 스레드가 하나씩 할당되므로 여러 업로드가 병렬로 진행됩니다. 자리 표시자 MediaAttachment는 동기적으로 추가되며, 업로드가 완료되면 해당 ref가 채워집니다. span이 내보내지기 전에 Ref가 반드시 채워집니다(빌드 경로에서 _await_uploads를 통해 진행 중인 업로드가 완료될 때까지 기다립니다).

`method` `attach_media_url`

attach_media_url(url: 'str', modality: 'str' = '') → LLM

이 LLM Call에 미디어 URL을 첨부합니다. 호출자가 업스트림 메시지에서 받은 URL 문자열을 가지고 있는 일반적인 경우에 attach_media 대신 간편하게 사용할 수 있는 메서드입니다. data: URL은 바이트로 파싱된 후 게시되고, 일반 URI는 가져온 후 게시됩니다. 빈 URL은 무시됩니다. 메서드 체이닝을 위해 self를 반환합니다.

`method` `end`

end() → None

`method` `model_post_init`

model_post_init(context: 'Any') → None

`method` `output`

output(content: 'str') → LLM

output_messages에 assistant 메시지를 추가합니다.

`방법` `record`

record(
    input_messages: 'list[Message] | None' = None,
    output_messages: 'list[Message] | None' = None,
    media_attachments: 'list[MediaAttachment] | None' = None,
    usage: 'Usage | None' = None,
    reasoning: 'Reasoning | str | None' = None,
    response_id: 'str | None' = None,
    response_model: 'str | None' = None,
    finish_reasons: 'list[str] | None' = None,
    output_type: 'str | None' = None
) → LLM

한 번의 호출로 여러 LLM Call 필드를 설정합니다. 수동으로 계측된 에이전트는 일반적으로 LLM Call이 끝날 때 8개 이상의 개별 필드(input_messages, output_messages, usage, response_id 등)를 하나씩 부여하여 chat span을 구축합니다. record(...)는 이를 단일 키워드 호출로 합쳐 주므로 기록하는 코드를 간결하게 유지할 수 있습니다. 명시적으로 전달된(None이 아닌) 필드만 적용되며, 기존 값은 그대로 유지됩니다. reasoning에는 Reasoning 인스턴스 또는 일반 string(자동으로 래핑됨)을 전달할 수 있습니다. 메서드 체이닝을 위해 self를 반환합니다.

`method` `set_attributes`

set_attributes(attributes: 'dict[str, Any]') → Self

이 span에 임의의 OTel 속성을 설정합니다. 키가 하나든 여러 개든 dict를 전달하세요. 키가 하나뿐이라면 span.set_attributes({"weave.tag": "value"})처럼 호출합니다. OTel의 Span.set_attributes와 동일하게 동작합니다. span이 시작된 후 종료되기 전, 즉 with 블록 안에서 호출해야 합니다. 이 범위 밖에서 호출하면 아무 작업도 수행하지 않고 경고만 로깅합니다. 배치 수집 시에는 객체에 선언된 필드를 직접 채운 다음 log_turn / log_conversation에 전달하세요.

`method` `think`

think(content: 'str') → LLM

추론(chain-of-thought) 콘텐츠를 설정합니다.

`class` `LogResult`

일괄 log_* 호출의 결과입니다. Pydantic Fields:

conversation_id: <class 'str'>
trace_ids: list[str]
root_span_ids: list[str]
span_count: <class 'int'>

`클래스` `Markdown`

렌더링 가능한 Markdown 객체입니다. 인수:

markup (str): Markdown이 포함된 string입니다.
code_theme (str, 선택): 코드 블록에 사용할 Pygments 테마입니다. 기본값은 “monokai”입니다. 코드 테마는 https://pygments.org/styles/ 를 참조하세요.
justify (JustifyMethod, 선택): 단락의 정렬 값입니다. 기본값은 None입니다.
style (Union[str, Style], 선택): Markdown에 적용할 스타일입니다(선택 사항).
hyperlinks (bool, 선택): 하이퍼링크 활성화 여부입니다. 기본값은 True입니다.

`method` `init`

__init__(
    markup: 'str',
    code_theme: 'str' = 'monokai',
    justify: 'JustifyMethod | None' = None,
    style: 'str | Style' = 'none',
    hyperlinks: 'bool' = True,
    inline_code_lexer: 'str | None' = None,
    inline_code_theme: 'str | None' = None
) → None

`class` `MediaAttachment`

LLM Call에 첨부된 미디어입니다. 항상 weave:// 콘텐츠 ref URI를 담고 있습니다. 원시 바이트, data URL, 일반 HTTP URI는 여기에 저장되기 전에 LLM.attach_media를 통해 게시된 Content 객체로 변환됩니다.

inline_code_lexer: (str, 선택): 인라인 코드 구문 강조가 활성화된 경우 사용할 Lexer입니다. 기본값은 None입니다.
inline_code_theme: (Optional[str], 선택): 인라인 코드 구문 강조에 사용할 Pygments 테마입니다. 구문 강조를 사용하지 않으려면 None으로 지정하세요. 기본값은 None입니다. Pydantic Fields:
ref: <class 'str'>
modality: <class 'str'>
mime_type: <class 'str'>

`class` `Message`

대화 내의 단일 메시지입니다. 두 가지 생성 방식을 지원합니다.

플랫 방식(하위 호환, 일반 텍스트에 사용하기 편리함): Message(role="assistant", content="Hi there")
명시적 파트 방식(더 다양한 기능 제공 — 도구 호출, 추론과 텍스트 혼합, 인라인 미디어 지원): Message(role="assistant", parts=[TextPart(content="Let me check"), ToolCallPart(id="c1", name="get_weather", arguments='{...}')])

parts가 비어 있지 않으면 이 값이 정식 표현으로 사용됩니다. 비어 있으면 직렬화기가 플랫 필드를 바탕으로 단일 TextPart(role="tool"인 경우 ToolCallResponsePart)를 생성합니다. Pydantic Fields:

role: typing.Literal['user', 'assistant', 'system', 'tool']
content: <class 'str'>
tool_call_id: <class 'str'>
tool_name: <class 'str'>
parts: list[typing.Annotated[conversation.types.TextPart | conversation.types.ReasoningPart | conversation.types.ToolCallPart | conversation.types.ToolCallResponsePart | conversation.types.BlobPart | conversation.types.UriPart | conversation.types.FilePart, FieldInfo(annotation=NoneType, required=True, discriminator='type')]]

`클래스 메서드` `assistant`

assistant(
    text: 'str' = '',
    tool_calls: 'list[ToolCallPart] | None' = None
) → Message

텍스트와 도구 호출(선택)을 포함하는 assistant 메시지를 생성합니다. 단순한 응답에는 일반 텍스트를 사용하고, assistant가 하나 이상의 도구를 요청할 때는 tool_calls를 전달하세요. 둘 다 있으면 텍스트가 맨 앞의 TextPart로 출력되고 그 뒤에 각 ToolCallPart가 이어지므로, 채팅 뷰에서 이들이 인라인으로 렌더링됩니다.

`클래스 메서드` `system`

system(text: 'str') → Message

일반 텍스트로 시스템 메시지를 생성합니다.

`클래스 메서드` `tool_result`

tool_result(call_id: 'str', output: 'Any') → Message

이전에 요청된 도구 Call에 대한 도구 결과 메시지를 생성합니다. output은 string, dict, list, 스칼라 또는 None일 수 있으며, 내부의 ToolCallResponsePart가 string이 아닌 값은 JSON으로 인코딩합니다.

`클래스 메서드` `user`

user(text: 'str') → Message

일반 텍스트로 사용자 메시지를 생성합니다.

`클래스` `MessagesPrompt`

`method` `init`

__init__(messages: list[dict])

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
messages: list[dict]

`method` `format`

format(**kwargs: Any) → list

`method` `format_message`

format_message(message: dict, **kwargs: Any) → dict

템플릿 변수를 치환하여 단일 메시지의 형식을 지정합니다. 이 메서드는 실제 형식 지정 로직을 독립 함수인 format_message_with_template_vars에 위임합니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`class` `Model`

입력을 처리하는 코드와 데이터의 조합을 캡처하기 위한 클래스입니다. 예를 들어 프롬프트로 LLM을 호출하여 예측을 수행하거나 텍스트를 생성할 수 있습니다. 모델을 정의하는 속성이나 코드를 변경하면 해당 변경 사항이 로깅되고 버전이 업데이트됩니다. 따라서 모델의 여러 버전 간에 예측을 비교할 수 있습니다. 이 클래스를 사용하여 프롬프트를 반복적으로 개선하거나, 최신 LLM을 사용해 보고 다양한 설정에서의 예측을 비교하세요. 예시:

class YourModel(Model):
     attribute1: str
     attribute2: int

     @weave.op
     def predict(self, input_data: str) -> dict:
         # 여기에 모델 로직 작성
         prediction = self.attribute1 + ' ' + input_data
         return {'pred': prediction}

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None

`method` `get_infer_method`

get_infer_method() → Callable

`class` `Monitor`

들어오는 Call에 자동으로 점수를 매기는 모니터를 설정합니다. op 이름은 Weave 클라이언트에 설정된 entity와 프로젝트를 기준으로 weave ref로 변환됩니다. 하나의 클라이언트로 여러 entity와 프로젝트를 다루는 경우에는 정규화된 전체 weave ref를 지정해야 합니다. 자세한 내용은 _normalized_op_names를 참조하세요. 예시:

import weave
from weave.scorers import ValidJSONScorer

json_scorer = ValidJSONScorer()

my_monitor = weave.Monitor(
     name="my-monitor",
     description="This is a test monitor",
     sampling_rate=0.5,
     op_names=["my_op"],
     query={
         "$expr": {
             "$gt": [
                 {
                         "$getField": "started_at"
                     },
                     {
                         "$literal": 1742540400
                     }
                 ]
             }
         }
     },
     scorers=[json_scorer],
)

my_monitor.activate()

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
sampling_rate: <class 'float'>
scorers: list[flow.scorer.Scorer]
op_names: list[typing.Union[typing.Literal['genai.turn_ended'], str]]
query: trace_server.interface.query.Query | None
is_traced: <class 'bool'>
active: <class 'bool'>
scorer_debounce_config: flow.monitor.ScorerDebounceConfig | None

`method` `activate`

activate() → ObjectRef

모니터를 활성화합니다. 반환값: 모니터의 ref입니다.

`method` `deactivate`

deactivate() → ObjectRef

모니터를 비활성화합니다. 반환값: 모니터의 ref입니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `model_post_init`

model_post_init(context: Any) → None

클라이언트를 사용할 수 있는 경우 생성 시점에 op_names를 정규화합니다. 게시(publish)에는 객체별 훅이 없으므로, activate() 없이 weave.publish(monitor)만 호출하는 경우도 처리할 수 있도록 여기서 짧은 이름을 확장합니다. 게시하려는 사용자는 대개 이미 weave.init을 호출했으므로, 모니터를 생성할 때 클라이언트가 설정되어 있습니다. 단위 테스트, 검사, 워커에서 저장된 모니터를 역직렬화하는 경우 등 클라이언트 없이 생성하는 사용 사례가 여럿 있습니다. get_weave_client()에 대한 가드가 있으므로 클라이언트 없이도 생성할 수 있습니다. 이 경우 정규화는 수행되지 않지만, 저장된 모니터에는 이미 전체 ref가 들어 있으므로 문제가 없습니다. 단, SDK로 모니터를 생성할 때 정규화가 되지 않는 예외적인 경우가 있습니다. 사용자가 모니터를 생성한 뒤 weave.init을 호출하고, 그다음 모니터를 게시하는 경우입니다. 이때는 activate() 또는 deactivate()를 호출하여 문제를 우회할 수 있습니다.

`class` `Object`

추적 및 버전 관리가 가능한 Weave 객체의 기본 클래스입니다. 이 클래스는 Pydantic의 BaseModel을 확장하여 객체 추적, 참조, 직렬화를 위한 Weave 전용 기능을 제공합니다. 객체에는 이름, 설명, 참조를 지정할 수 있으며, 이를 통해 Weave 시스템에 객체를 저장하고 조회할 수 있습니다. 속성:

name (str | None): 사람이 읽기 쉬운 객체 이름입니다.
description (str | None): 객체가 무엇을 나타내는지에 대한 설명입니다.
ref (ObjectRef | None): Weave 시스템 내 객체에 대한 참조입니다.

예시:

# 단순한 객체 생성
obj = Object(name="my_object", description="A test object")

# URI에서 객체 생성
obj = Object.from_uri("weave:///entity/project/object:digest")

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None

`클래스 메서드` `from_uri`

from_uri(uri: str, objectify: bool = True) → Self

Weave URI에서 객체 인스턴스를 생성합니다. 인수:

uri (str): 객체를 가리키는 Weave URI입니다.
objectify (bool): 결과를 객체화할지 여부입니다. 기본값은 True입니다.

반환값:

Self: URI에서 생성된 클래스 인스턴스입니다.

예외:

NotImplementedError: 클래스가 역직렬화에 필요한 메서드를 구현하지 않은 경우 발생합니다.

예시:

obj = MyObject.from_uri("weave:///entity/project/object:digest")

`클래스 메서드` `handle_relocatable_object`

handle_relocatable_object(
    v: Any,
    handler: ValidatorFunctionWrapHandler,
    info: ValidationInfo
) → Any

ObjectRef 및 WeaveObject를 포함한 재배치 가능한 객체의 검증을 처리합니다. 이 검증기는 입력이 ObjectRef 또는 WeaveObject라서 표준 Object 인스턴스로 올바르게 변환해야 하는 특수한 경우를 처리합니다. 검증 과정에서 레퍼런스가 유지되고 무시되는 유형이 올바르게 처리되도록 합니다. 인수:

v (Any): 검증할 값입니다.
handler (ValidatorFunctionWrapHandler): 표준 pydantic 검증 핸들러입니다.
info (ValidationInfo): 검증 컨텍스트 정보입니다.

반환값:

Any: 검증된 객체 인스턴스입니다.

예시: 이 메서드는 객체 생성 및 검증 시 자동으로 호출되며, 다음과 같은 경우를 처리합니다: ```python

ObjectRef를 전달하는 경우

obj = MyObject(some_object_ref)

WeaveObject가 전달되는 경우

obj = MyObject(some_weave_object)

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/object/obj.py#L91" />

### <kbd>classmethod</kbd> `strip_weave_serialization_metadata`

```python
strip_weave_serialization_metadata(data: Any) → Any

dict 입력에서 Weave 직렬화 메타데이터를 제거합니다. Weave는 직렬화 과정에서 유형 재구성을 위해 dict에 _type, _class_name, _bases를 추가합니다. 이 필드들은 실제 모델 필드가 아니므로, extra=“forbid”를 사용하는 Pydantic 검증 전에 반드시 제거해야 합니다.

`class` `ObjectRef`

ObjectRef(entity: ‘str’, project: ‘str’, name: ‘str’, _digest: ‘str | Future[str]’, _extra: ‘tuple[str | Future[str], …]’ = ())

`method` `init`

__init__(
    entity: 'str',
    project: 'str',
    name: 'str',
    _digest: 'str | Future[str]',
    _extra: 'tuple[str | Future[str], ]' = ()
) → None

`property` digest

`property` extra

`property` is_digest_resolved

`method` `as_param_dict`

as_param_dict() → dict

`method` `delete`

delete() → None

`method` `get`

get(objectify: 'bool' = True) → Any

`method` `is_descended_from`

is_descended_from(potential_ancestor: 'ObjectRef') → bool

`method` `maybe_parse_uri`

maybe_parse_uri(s: 'str') → AnyRef | None

`method` `parse_uri`

parse_uri(uri: 'str') → ObjectRef

`method` `with_attr`

with_attr(attr: 'str') → Self

`method` `with_extra`

with_extra(extra: 'tuple[str | Future[str], ]') → Self

`method` `with_index`

with_index(index: 'int') → Self

`method` `with_item`

with_item(item_digest: 'str | Future[str]') → Self

`method` `with_key`

with_key(key: 'str') → Self

`class` `Prompt`

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None

`method` `format`

format(**kwargs: Any) → Any

`class` `SavedView`

SavedView 객체를 다루는 플루언트 스타일 클래스입니다.

`method` `init`

__init__(view_type: 'str' = 'traces', label: 'str' = 'SavedView') → None

`property` entity

`property` label

`property` project

`property` view_type

`method` `add_column`

add_column(path: 'str | ObjectPath', label: 'str | None' = None) → SavedView

`method` `add_columns`

add_columns(*columns: 'str') → SavedView

그리드에 여러 열을 추가하는 편의 메서드입니다.

`method` `add_filter`

add_filter(
    field: 'str',
    operator: 'str',
    value: 'Any | None' = None
) → SavedView

`method` `add_sort`

add_sort(field: 'str', direction: 'SortDirection') → SavedView

`method` `column_index`

column_index(path: 'int | str | ObjectPath') → int

`method` `filter_op`

filter_op(op_name: 'str | None') → SavedView

`method` `get_calls`

get_calls(
    limit: 'int | None' = None,
    offset: 'int | None' = None,
    include_costs: 'bool' = False,
    include_feedback: 'bool' = False,
    all_columns: 'bool' = False
) → CallsIter

이 저장된 뷰의 필터 및 설정과 일치하는 Call을 조회합니다.

`method` `get_known_columns`

get_known_columns(num_calls_to_query: 'int | None' = None) → list[str]

존재하는 것으로 확인된 열 집합을 조회합니다.

`method` `get_table_columns`

get_table_columns() → list[TableColumn]

`method` `hide_column`

hide_column(col_name: 'str') → SavedView

`method` `insert_column`

insert_column(
    idx: 'int',
    path: 'str | ObjectPath',
    label: 'str | None' = None
) → SavedView

`클래스 메서드` `load`

load(ref: 'str') → Self

`method` `page_size`

page_size(page_size: 'int') → SavedView

`method` `pin_column_left`

pin_column_left(col_name: 'str') → SavedView

`method` `pin_column_right`

pin_column_right(col_name: 'str') → SavedView

`method` `remove_column`

remove_column(path: 'int | str | ObjectPath') → SavedView

`method` `remove_columns`

remove_columns(*columns: 'str') → SavedView

저장된 뷰에서 열을 제거합니다.

`method` `remove_filter`

remove_filter(index_or_field: 'int | str') → SavedView

`method` `remove_filters`

remove_filters() → SavedView

저장된 뷰에서 모든 필터를 제거합니다.

`method` `rename`

rename(label: 'str') → SavedView

`method` `rename_column`

rename_column(path: 'int | str | ObjectPath', label: 'str') → SavedView

`method` `save`

save() → SavedView

저장된 뷰를 서버에 게시합니다.

`method` `set_columns`

set_columns(*columns: 'str') → SavedView

그리드에 표시할 열을 설정합니다.

`method` `show_column`

show_column(col_name: 'str') → SavedView

`method` `sort_by`

sort_by(field: 'str', direction: 'SortDirection') → SavedView

`method` `to_grid`

to_grid(limit: 'int | None' = None) → Grid

`method` `to_rich_table_str`

to_rich_table_str() → str

`method` `ui_url`

ui_url() → str | None

UI에서 이 저장된 뷰를 표시하는 URL입니다. 이 URL은 트레이스 등을 보여 주는 “결과” 페이지의 URL이며, 뷰 객체 자체의 URL이 아닙니다.

`method` `unpin_column`

unpin_column(col_name: 'str') → SavedView

`class` `Scorer`

Pydantic 필드:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
column_map: dict[str, str] | None

`property` display_name

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`method` `model_post_init`

model_post_init(context: Any) → None

`method` `score`

score(output: Any, **kwargs: Any) → Any

`method` `summarize`

summarize(score_rows: list) → dict | None

`class` `Session`

:class:weave.Conversation의 사용 중단된 별칭입니다. 기존 session_id / session_name 생성자 필드를 받을 수 있으며, 이 필드들을 conversation_id / conversation_name으로 프록시하는 읽기/쓰기 속성으로도 노출합니다. 원래 Session에서는 이 필드들이 모델 필드였으므로, s.session_id를 조회하거나 값을 부여하는 기존 코드도 그대로 작동합니다.

`method` `init`

__init__(**data: 'Any') → None

Pydantic Fields:

conversation_id: <class 'str'>
conversation_name: <class 'str'>
agent_name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
include_content: <class 'bool'>
continue_parent_trace: <class 'bool'>
attributes: dict[str, typing.Any]

`property` session_id

:attr:conversation_id의 사용 중단된 별칭입니다.

`property` session_name

:attr:conversation_name의 사용 중단된 별칭입니다.

`클래스` `StringPrompt`

`method` `init`

__init__(content: str)

Pydantic Fields:

name: str | None
description: str | None
ref: trace.refs.ObjectRef | None
content: <class 'str'>

`method` `format`

format(**kwargs: Any) → str

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`class` `SubAgent`

turn 내에서 위임된 에이전트 호출입니다. 동일한 트레이스 안에 중첩된 invoke_agent OTel span에 매핑됩니다. Pydantic Fields:

name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

이 span 내의 특정 시점에 OTel span 이벤트를 기록합니다. .. deprecated: ``` 이 데이터는 대신 set_attributes로 기록하세요. OpenTelemetry는 Span Event API(Span.add_event)를 단계적으로 사용 중단하고 있습니다. add_event는 여전히 작동하며 기존 span 이벤트 데이터도 계속 유효합니다. 자세한 내용은 https://opentelemetry.io/blog/2026/deprecating-span-events/ 를 참조하세요.

마커 또는 라이프사이클 데이터를 기록할 때 사용하세요. 권한 프롬프트(예: ``weave.permission_request``), 라이프사이클 전환(예: ``spawned`` / ``streaming`` / ``finished``), 또는 span의 수명 중 특정 시점에 발생하는 맞춤형 마일스톤이 여기에 해당합니다. 이와 달리 속성은 span 전체에 적용되는 속성입니다. 

span 시작과 span 종료 사이(``with`` 블록 내부)에서 호출해야 합니다. 이 윈도우 밖에서 호출하면 아무 작업도 수행되지 않으며 경고가 로깅됩니다. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L843" />

### <kbd>method</kbd> `end`

```python
end() → None

`method` `llm`

llm(
    model: 'str' = '',
    provider_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → LLM

이 하위 에이전트 내에서 LLM Call을 시작합니다. 컨텍스트 매니저 사용 여부와 관계없이 get_current_llm()으로 LLM에 접근할 수 있도록 _current_llm contextvar를 설정합니다.

`method` `record`

record(
    name: 'str | None' = None,
    model: 'str | None' = None,
    system_instructions: 'list[str] | None' = None,
    agent_id: 'str | None' = None,
    agent_description: 'str | None' = None,
    agent_version: 'str | None' = None
) → SubAgent

한 번의 호출로 여러 하위 에이전트 필드를 설정합니다. 수동으로 계측된 에이전트가 하위 에이전트에 필드별로 개별 할당하던 작업(system_instructions, agent_id, …)을 한 번의 키워드 호출로 통합합니다. 명시적으로 전달된(None이 아닌) 필드만 적용되며, 기존 값은 그대로 유지됩니다. 메서드 체이닝을 위해 self를 반환합니다. Turn.record / LLM.record와 동일한 방식으로 동작합니다. 참고: 스트리밍(with) 경로에서는 하위 에이전트 span의 이름이 __enter__ 시점의 name으로 정해집니다. 따라서 span 이름에 이 값을 반영해야 한다면 record 대신 start_subagent / turn.subagent를 통해 name을 설정하세요. 이 경우에도 record는 gen_ai.agent.name 속성을 업데이트합니다.

`method` `set_attributes`

set_attributes(attributes: 'dict[str, Any]') → Self

이 span에 임의의 OTel 속성을 설정합니다. 키가 하나든 여러 개든 dict를 전달하세요. 키가 하나뿐이라면 span.set_attributes({"weave.tag": "value"})처럼 호출합니다. OTel의 Span.set_attributes와 동일하게 동작합니다. span이 시작된 후 종료되기 전, 즉 with 블록 안에서 호출해야 합니다. 이 범위 밖에서 호출하면 아무 작업도 수행하지 않고 경고만 로깅합니다. 일괄 수집 시에는 객체에 선언된 필드를 직접 채운 다음 log_turn / log_conversation에 전달하세요.

`method` `tool`

tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool

이 하위 에이전트 내에서 도구 실행을 시작합니다.

`클래스` `Table`

`method` `init`

__init__(rows: 'list[dict]') → None

`property` rows

`method` `append`

append(row: 'dict') → None

table에 행을 추가합니다.

`method` `pop`

pop(index: 'int') → None

table에서 지정한 인덱스의 행을 제거합니다.

`class` `ContextAwareThread`

호출자의 컨텍스트로 함수를 실행하는 Thread입니다. 이 클래스는 threading.Thread를 그대로 대체할 수 있는 drop-in replacement로, 스레드 내부에서도 Call이 예상대로 동작하도록 보장합니다. Weave가 동작하려면 특정 contextvar가 설정되어 있어야 합니다(call_context.py 참조). 하지만 새 스레드는 부모 스레드의 컨텍스트를 자동으로 복사하지 않으므로 call 컨텍스트가 유실될 수 있으며, 이는 바람직하지 않습니다! 이 클래스는 contextvar 복사를 자동으로 처리하므로, 이 스레드를 사용하면 사용자가 기대하는 대로 별도 설정 없이 “그냥 동작”합니다. 이 클래스를 사용하지 않으려면 다음과 같이 작성해도 동일한 효과를 얻을 수 있습니다.

def run_with_context(func, *args, **kwargs):
     context = copy_context()
     def wrapper():
         context.run(func, *args, **kwargs)
     return wrapper

thread = threading.Thread(target=run_with_context(your_func, *args, **kwargs))
thread.start()

`method` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

`property` daemon

이 스레드가 데몬 스레드인지 여부를 나타내는 불리언 값입니다. 이 값은 start()를 호출하기 전에 설정해야 하며, 그렇지 않으면 RuntimeError가 발생합니다. 초기값은 이 스레드를 생성한 스레드에서 상속됩니다. 메인 스레드는 데몬 스레드가 아니므로 메인 스레드에서 생성된 모든 스레드는 기본적으로 daemon = False입니다. 데몬 스레드만 남으면 Python 프로그램 전체가 종료됩니다.

`property` ident

이 스레드의 스레드 식별자입니다. 스레드가 시작되지 않은 경우 None입니다. 0이 아닌 정수입니다. get_ident() 함수를 참조하세요. 스레드가 종료된 후 다른 스레드가 생성되면 스레드 식별자가 재사용될 수 있습니다. 식별자는 스레드가 종료된 후에도 사용할 수 있습니다.

`property` name

식별 용도로만 사용되는 string입니다. 별도의 의미는 없습니다. 여러 스레드에 같은 이름을 지정할 수 있습니다. 초기 이름은 생성자에서 설정됩니다.

`property` native_id

이 스레드의 네이티브 정수 스레드 ID입니다. 스레드가 아직 시작되지 않았다면 None입니다. 이 값은 음이 아닌 정수입니다. get_native_id() 함수를 참조하세요. 커널이 보고하는 스레드 ID를 나타냅니다.

`method` `run`

run() → None

`class` `ThreadContext`

현재 스레드 및 턴 정보에 액세스할 수 있도록 해 주는 컨텍스트 객체입니다.

`method` `init`

__init__(thread_id: 'str | None')

지정된 thread_id로 ThreadContext를 초기화합니다. 인수:

`property` thread_id

이 컨텍스트의 thread_id를 조회합니다.

thread_id: 이 컨텍스트의 스레드 식별자입니다. 비활성화된 경우 None입니다. 반환값: 스레드 식별자입니다. 스레드 추적이 비활성화된 경우 None을 반환합니다.

`property` turn_id

활성 컨텍스트에서 현재 turn_id를 조회합니다. 반환값: 현재 turn_id가 설정되어 있으면 해당 값을 반환하고, 그렇지 않으면 None을 반환합니다.

`class` `ContextAwareThreadPoolExecutor`

호출자의 컨텍스트를 유지한 채 함수를 실행하는 ThreadPoolExecutor입니다. concurrent.futures.ThreadPoolExecutor를 그대로 대체할 수 있는 클래스로, executor 내부에서도 weave Call이 예상대로 동작하도록 보장합니다. Weave가 동작하려면 특정 contextvar가 설정되어 있어야 합니다(call_context.py 참조). 그러나 새 스레드는 부모 스레드의 컨텍스트를 자동으로 복사하지 않으므로 Call 컨텍스트가 유실될 수 있으며, 이는 바람직하지 않습니다. 이 클래스는 contextvar 복사를 자동으로 처리하므로, 이 executor를 사용하면 사용자가 기대하는 대로 “별도 설정 없이” 동작합니다. 이 클래스를 사용하지 않고 다음과 같이 작성해도 동일한 효과를 얻을 수 있습니다.

with concurrent.futures.ThreadPoolExecutor() as executor:
     contexts = [copy_context() for _ in range(len(vals))]

     def _wrapped_fn(*args):
         return contexts.pop().run(fn, *args)

     executor.map(_wrapped_fn, vals)

`method` `init`

__init__(*args: 'Any', **kwargs: 'Any') → None

`method` `map`

map(
    fn: 'Callable',
    *iterables: 'Iterable[Any]',
    timeout: 'float | None' = None,
    chunksize: 'int' = 1
) → Iterator

`method` `submit`

submit(fn: 'Callable', *args: 'Any', **kwargs: 'Any') → Any

`class` `Tool`

단일 도구 실행을 나타냅니다. execute_tool OTel span에 매핑됩니다. arguments와 result는 JSONString 어노테이션을 사용합니다. 호출자가 dict / list / 스칼라 값을 부여하면 SDK가 생성 시점 또는 부여 시점에 이를 JSON으로 인코딩합니다. 저장되는 값은 항상 문자열이며, GenAI semconv의 전송 형식과 일치합니다. Pydantic Fields:

name: <class 'str'>
arguments: <class 'str'>
result: <class 'str'>
tool_call_id: <class 'str'>
tool_type: <class 'str'>
tool_description: <class 'str'>
tool_definitions: <class 'str'>
duration_ms: <class 'int'>
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

이 span 내의 특정 시점에 OTel span 이벤트를 기록합니다. .. deprecated: ``` 이 데이터는 대신 set_attributes로 기록하세요. OpenTelemetry는 Span Event API(Span.add_event)를 단계적으로 폐지하고 있습니다. add_event는 계속 작동하며 기존 span 이벤트 데이터도 그대로 유효합니다. 자세한 내용은 https://opentelemetry.io/blog/2026/deprecating-span-events/ 를 참조하세요.

마커 / 라이프사이클 데이터를 기록할 때 사용하세요. 권한 프롬프트(예: ``weave.permission_request``), 라이프사이클 전환(예: ``spawned`` / ``streaming`` / ``finished``), 또는 span 수명 중 특정 시점에 발생하는 모든 맞춤형 마일스톤이 여기에 해당합니다(반면 속성은 span 전체에 적용되는 특성입니다). 

span 시작과 span 종료 사이(``with`` 블록 내부)에서 호출해야 합니다. 이 윈도우 밖에서 호출하면 아무 작업도 수행하지 않고 경고만 로깅합니다. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L382" />

### <kbd>method</kbd> `end`

```python
end() → None

`method` `set_attributes`

set_attributes(attributes: 'dict[str, Any]') → Self

이 span에 임의의 OTel 속성을 지정합니다. 키가 하나든 여러 개든 dict를 전달하세요. 키가 하나인 경우에는 span.set_attributes({"weave.tag": "value"})와 같이 사용합니다. OTel의 Span.set_attributes와 동일하게 동작합니다. span이 시작된 후 종료되기 전, 즉 with 블록 안에서 호출해야 합니다. 이 윈도우 밖에서 호출하면 아무 작업도 수행하지 않고 경고를 로깅합니다. 일괄 수집 시에는 객체에 선언된 필드를 직접 채운 다음 log_turn / log_conversation에 전달하세요.

`class` `Turn`

사용자와 에이전트 간의 한 차례 주고받음을 나타냅니다. invoke_agent OTel span에 매핑됩니다. 기본적으로 각 turn은 자체 OTel 트레이스를 시작하므로(continue_parent_trace=False) Agents 탭에는 turn마다 트레이스가 하나씩 표시됩니다. 외부 트레이스가 이미 활성 상태이고 에이전트 호출을 그 안에 중첩하려면(예: fastapi로 계측된 요청 내부) Conversation에(또는 Turn에 직접) continue_parent_trace=True를 설정하세요. Pydantic Fields:

agent_name: <class 'str'>
model: <class 'str'>
agent_id: <class 'str'>
agent_description: <class 'str'>
agent_version: <class 'str'>
system_instructions: list[str]
messages: list[conversation.types.Message]
spans: list[conversation.conversation.LLM | conversation.conversation.Tool | conversation.conversation.SubAgent]
continue_parent_trace: <class 'bool'>
started_at: datetime.datetime | None
ended_at: datetime.datetime | None

`method` `add_event`

add_event(
    name: 'str',
    attributes: 'dict[str, Any] | None' = None,
    timestamp: 'datetime | None' = None
) → Self

마커 또는 라이프사이클 데이터를 기록할 때 사용하세요. 권한 프롬프트(예: ``weave.permission_request``), 라이프사이클 전환(예: ``spawned`` / ``streaming`` / ``finished``), 그 밖에 span의 수명 동안 특정 시점에 발생하는 맞춤형 마일스톤이 여기에 해당합니다. 반면 attribute는 span 전체에 대한 속성입니다. 

span 시작과 span 종료 사이(``with`` 블록 내부)에서 호출해야 합니다. 이 윈도우 밖에서 호출하면 아무 작업도 수행하지 않고 경고만 로깅합니다. 

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L1033" />

### <kbd>method</kbd> `end`

```python
end() → None

`method` `llm`

llm(
    model: 'str' = '',
    provider_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → LLM

LLM Call(chat span, 이 turn의 하위 항목)을 시작합니다. 컨텍스트 관리자 사용 여부와 관계없이 get_current_llm()으로 LLM에 접근할 수 있도록 _current_llm contextvar를 설정합니다.

`method` `model_post_init`

model_post_init(context: 'Any') → None

`method` `record`

record(
    messages: 'list[Message] | None' = None,
    system_instructions: 'list[str] | None' = None,
    agent_name: 'str | None' = None,
    model: 'str | None' = None,
    agent_id: 'str | None' = None,
    agent_description: 'str | None' = None,
    agent_version: 'str | None' = None
) → Turn

한 번의 호출로 여러 턴 필드를 설정합니다. 수동으로 계측된 에이전트가 턴에 필드별로 개별 할당하던 작업(system_instructions, agent_id, …)을 단일 키워드 호출로 통합합니다. 명시적으로 전달된(None이 아닌) 필드만 적용되며, 기존 값은 유지됩니다. messages는 턴의 기존 메시지를 대체합니다(메시지 하나를 추가하는 Turn.user(...)와 다릅니다). 체이닝을 위해 self를 반환합니다. LLM.record와 같은 방식으로 동작합니다. 참고: 스트리밍(with) 경로에서는 __enter__ 시점에 agent_name을 기준으로 턴 span의 이름이 정해집니다. 따라서 span 이름에 agent_name을 반영해야 한다면 record 대신 start_turn에서 설정하세요. record를 사용해도 gen_ai.agent.name 속성은 업데이트됩니다.

`method` `set_attributes`

set_attributes(attributes: 'dict[str, Any]') → Self

이 span에 임의의 OTel 속성을 설정합니다. 키가 하나이든 여러 개이든 dict를 전달하세요. 키가 하나뿐이라면 span.set_attributes({"weave.tag": "value"})처럼 호출합니다. OTel의 Span.set_attributes와 동일하게 동작합니다. span이 시작된 후 종료되기 전, 즉 with 블록 안에서 호출해야 합니다. 이 범위 밖에서 호출하면 아무 작업도 수행하지 않고 경고를 로깅합니다. 일괄 수집 시에는 객체에 선언된 필드를 직접 채운 다음 log_turn / log_conversation에 전달하세요.

`method` `subagent`

subagent(
    name: 'str',
    model: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → SubAgent

하위 에이전트 호출을 시작합니다(동일한 트레이스 내에 중첩된 invoke_agent span 생성).

`method` `tool`

tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool

도구 실행(이 turn의 하위 span인 execute_tool span)을 시작합니다.

`method` `user`

user(content: 'str') → Turn

turn 도중에 사용자 메시지를 추가합니다.

`class` `Usage`

LLM Call의 토큰 사용량입니다. Pydantic Fields:

input_tokens: <class 'int'>
output_tokens: <class 'int'>
reasoning_tokens: <class 'int'>
cache_creation_input_tokens: <class 'int'>
cache_read_input_tokens: <class 'int'>

`function` `add_tags`

add_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

객체 버전에 태그를 추가합니다. 인수:

`function` `as_op`

as_op(fn: 'Callable[P, R]') → Op[P, R]

@weave.op 데코레이터가 적용된 함수를 받아 해당 함수의 Op를 반환합니다. @weave.op 데코레이터가 적용된 함수는 이미 Op의 인스턴스이므로, 이 함수는 런타임에 아무 작업도 하지 않습니다. 다만 OpDef 속성에 타입 안전하게 액세스해야 할 때 타입 검사기의 검사를 통과시키는 용도로 사용할 수 있습니다.

obj_ref: 객체 버전에 대한 레퍼런스입니다. ObjectRef(weave.publish()가 반환) 또는 weave /// URI string을 지정합니다.
tags: 추가할 태그 string 목록입니다. 인수:
fn: weave.op 데코레이터가 적용된 함수입니다. 반환값: 함수의 Op입니다.

`function` `attributes`

attributes(attributes: 'dict[str, Any]') → Iterator

호출에 속성을 설정하는 컨텍스트 관리자입니다. 예시:

with weave.attributes({'env': 'production'}):
     print(my_function.call("World"))

`function` `end_conversation`

end_conversation() → None

contextvar에 저장된 현재 대화를 종료합니다.

`function` `end_llm`

end_llm() → None

contextvar에서 가져온 현재 LLM Call을 종료합니다.

`function` `end_session`

end_session() → None

:func:weave.end_conversation의 사용 중단된 별칭입니다.

`function` `end_turn`

end_turn() → None

contextvar에 저장된 현재 turn을 종료합니다.

`function` `finish`

finish() → None

Weave로의 로깅을 중지합니다. finish를 호출한 후에는 weave.op 데코레이터가 적용된 함수의 Call이 더 이상 로깅되지 않습니다. 로깅을 재개하려면 weave.init()을 다시 실행하세요.

`function` `get`

get(uri: 'str | ObjectRef') → Any

URI로 객체를 조회하는 편의 함수입니다. Weave로 로깅한 객체 중 상당수는 Weave 서버에 자동으로 등록됩니다. 이 함수를 사용하면 이러한 객체를 URI로 조회할 수 있습니다. 인수:

uri: 전체 경로를 포함한 정규화된 weave ref URI입니다. 반환값: 해당 객체입니다.

예시:

weave.init("weave_get_example")
dataset = weave.Dataset(rows=[{"a": 1, "b": 2}])
ref = weave.publish(dataset)

dataset2 = weave.get(ref)  # dataset과 동일!

`function` `get_aliases`

get_aliases(obj_ref: 'ObjectRef | str') → list[str]

객체 버전의 별칭을 조회합니다. 인수:

obj_ref: 객체 버전에 대한 레퍼런스입니다. ObjectRef 또는 weave /// URI string을 사용할 수 있습니다. 반환값: 별칭 string 목록입니다.

`function` `get_client`

get_client() → WeaveClient | None

`function` `get_current_call`

get_current_call() → Call | None

현재 실행 중인 Op 내부에서 해당 Op의 Call 객체를 조회합니다. 반환값: 현재 실행 중인 Op의 Call 객체입니다. 추적이 초기화되지 않았거나 이 메서드를 Op 외부에서 호출한 경우에는 None을 반환합니다. 참고:

반환된 Call의 attributes 딕셔너리는 호출이 시작된 후에는 변경할 수 없습니다. 호출 메타데이터를 설정하려면 Op를 호출하기 전에 :func:weave.attributes를 사용하세요. summary 필드는 Op 실행 중에 업데이트할 수 있으며, 호출이 종료되면 계산된 요약 정보와 병합됩니다.

`function` `get_current_conversation`

get_current_conversation() → Conversation | None

contextvar에서 현재 활성 대화를 반환하며, 활성 대화가 없으면 None을 반환합니다.

`function` `get_current_llm`

get_current_llm() → LLM | None

contextvar에서 활성 LLM Call을 반환하며, 없으면 None을 반환합니다.

`function` `get_current_session`

get_current_session() → Conversation | None

:func:weave.get_current_conversation의 사용 중단된 별칭입니다.

`function` `get_current_turn`

get_current_turn() → Turn | None

contextvar에서 현재 활성 턴을 반환하며, 활성 턴이 없으면 None을 반환합니다.

`function` `get_tags`

get_tags(obj_ref: 'ObjectRef | str') → list[str]

객체 버전의 태그를 조회합니다. 인수:

obj_ref: 객체 버전의 레퍼런스로, ObjectRef 또는 weave /// URI string입니다. 반환값: 태그 string 목록입니다.

`function` `get_tags_and_aliases`

get_tags_and_aliases(obj_ref: 'ObjectRef | str') → tuple[list[str], list[str]]

단일 Call로 객체 버전의 태그와 별칭을 한 번에 조회합니다. 인수:

obj_ref: 객체 버전에 대한 레퍼런스입니다. ObjectRef 또는 weave /// URI string을 사용할 수 있습니다. 반환값: (tags, aliases) 형태의 튜플입니다. 두 값 모두 string 목록입니다.

`function` `init`

init(
    project_name: 'str',
    settings: 'UserSettings | dict[str, Any] | None' = None,
    autopatch_settings: 'AutopatchSettings | None' = None,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    global_postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    global_postprocess_output: 'PostprocessOutputFunc | None' = None,
    global_attributes: 'dict[str, Any] | None' = None
) → WeaveClient

Weave 추적을 초기화하고 wandb 프로젝트에 로깅합니다. 로깅은 전역으로 초기화되므로 init의 반환 값에 대한 참조를 유지할 필요가 없습니다. init을 호출한 후에는 weave.op 데코레이터가 적용된 함수의 Call이 지정된 프로젝트에 로깅됩니다. 인수: 참고: 클라이언트 수준 후처리는 각 op 자체의 후처리가 끝난 후에 실행됩니다. 실행 순서는 항상 다음과 같습니다. 1. op별 후처리 2. 클라이언트 수준 후처리

project_name: 로깅할 Weights & Biases 팀 및 프로젝트의 이름입니다. 팀을 지정하지 않으면 기본 entity가 사용됩니다. 기본 entity를 확인하거나 변경하려면 W&B Models 문서의 User Settings를 참고하세요.
settings: Weave 클라이언트의 전반적인 설정입니다. UserSettings 인스턴스 또는 다음 키를 포함하는 dict를 지정할 수 있습니다(모두 선택 사항). 모든 설정은 접두사 WEAVE_를 붙인 환경 변수로도 설정할 수 있습니다(예: WEAVE_DISABLED=true). 사용 가능한 설정: - disabled (bool): 모든 함수의 트레이스를 비활성화합니다. 기본값: False - print_call_link (bool): Op의 Weave UI 링크를 터미널에 출력합니다. 기본값: True - log_level (str): 로깅할 정보의 유형을 설정합니다(DEBUG, INFO, WARNING, ERROR, CRITICAL). 기본값: INFO - display_viewer (str): Weave가 콘솔에 객체를 표시하는 방식을 제어합니다(auto, rich, print). 기본값: auto - capture_code (bool): 트레이스된 Op의 코드를 Weave 프로젝트에 캡처합니다. 기본값: True - implicitly_patch_integrations (bool): 지원되는 라이브러리를 자동으로 패치합니다. 기본값: True - redact_pii (bool): 모든 트레이스 데이터에서 이메일, 전화번호, 신용카드 번호 등의 민감한 정보를 찾아 서버로 전송하기 전에 자리 표시자 값으로 대체합니다. presidio-analyzer 및 presidio-anonymizer 패키지가 필요합니다.
Default: False - redact_pii_fields (list[str]): redact_pii가 True일 때 마스킹할 PII 엔티티 유형을 지정합니다. 비어 있으면 Presidio의 기본 세트를 사용합니다. 예시: [‘EMAIL’,‘PHONE_NUMBER’,‘CREDIT_CARD’,‘US_SSN’]. 전체 목록은 https://microsoft.github.io/presidio/supported_entities/ 에서 확인하세요.
Default: [] - redact_pii_exclude_fields (list[str]): 제외할 PII entity 유형입니다. 기본값: [] - capture_client_info (bool): Python/SDK 버전 정보를 캡처합니다. 기본값: True - capture_system_info (bool): OS 정보를 캡처합니다. 기본값: True - client_parallelism (int): 백그라운드 Op에 사용할 워커 수입니다. 기본값: auto - use_server_cache (bool): 서버 응답의 로컬 디스크 캐싱을 활성화합니다. - server_cache_size_limit (int): 캐시 크기 한도(바이트)입니다. 기본값: 1_000_000_000 - server_cache_dir (str): 서버 캐시를 저장할 디렉터리입니다. 기본값: temporary - scorers_dir (str): Scorer 모델 체크포인트를 저장할 디렉터리입니다. 기본값: ~/.cache/wandb/weave-scorers - max_calls_queue_size (int): 큐의 최대 크기입니다(0 = 무제한). 기본값: 100_000 - retry_max_interval (float): 최대 재시도 간격(초)입니다. 기본값: 300 - retry_max_attempts (int): 최대 재시도 횟수입니다. 기본값: 3 - enable_disk_fallback (bool): 누락된 항목을 디스크에 기록합니다. 기본값: True - use_parallel_table_upload (bool): 대용량 table의 병렬 청크 업로드를 활성화합니다. False이면 table을 더 작은 청크 단위로 순차 업로드합니다.
Default: True - http_timeout (float): HTTP 요청이 완료될 때까지 기다리는 최대 시간(초)입니다. 연결 시간, 데이터 전송 시간, 서버 처리 시간이 모두 포함됩니다. 네트워크가 느리거나 대용량 페이로드를 다룰 때는 이 값을 늘리세요.
Default: 30.0 - use_stainless_server (bool): Stainless로 생성된 HTTP 클라이언트를 사용합니다. 이 클라이언트는 향상된 타입 안전성, 자동 재시도, 개선된 오류 처리를 제공합니다. 이 기능은 실험적 기능이며 향후 버전에서 기본값이 될 수 있습니다.
Default: False - use_calls_complete (bool): 시작 요청과 종료 요청을 따로 보내는 대신, 완료된 Call 데이터(시작 및 종료)를 하나의 요청으로 묶어 전송하는 최적화된 쓰기 경로를 사용합니다. 서버 부하를 줄이고 성능을 높일 수 있으며, 특히 실행 시간이 짧은 Op에서 효과가 큽니다.
Default: True - use_otel_v2: (bool): OTel을 지원하는 인테그레이션을 각 인테그레이션의 OTel 버전으로 라우팅합니다.
Default: True
autopatch_settings: (사용 중단) autopatch 인테그레이션 설정입니다. 대신 명시적 패치를 사용하세요.
postprocess_inputs: 이 클라이언트가 트레이스하는 모든 op의 입력에 적용할 함수입니다.
postprocess_output: 이 클라이언트가 트레이스하는 모든 op의 출력에 적용할 함수입니다.
attributes: 이 클라이언트가 생성하는 모든 트레이스에 적용할 속성 딕셔너리입니다. 반환값: Weave 클라이언트입니다.

`function` `link_prompt_to_registry`

link_prompt_to_registry(
    prompt: 'LinkablePrompt',
    target_path: 'str',
    aliases: 'Sequence[str] | None' = None
) → LinkAssetToRegistryRes

게시된 프롬프트 버전을 레지스트리에 연결합니다. 인수:

prompt: 게시된 프롬프트, ObjectRef 또는 완전 수식된 weave ///… URI string입니다.
target_path: <registry_project>/<portfolio_name> 형식의 레지스트리 대상 경로입니다(예: wandb-registry-prompts/my-prompt-collection).
aliases: 생성되는 레지스트리 버전에 추가할 별칭입니다(선택). 반환값:
LinkAssetToRegistryRes: registry-link 엔드포인트의 응답을 파싱한 결과입니다.

`function` `list_aliases`

list_aliases() → list[str]

프로젝트에 있는 모든 고유 별칭을 나열합니다. 반환값: 프로젝트에 있는 모든 별칭 string을 정렬한 목록입니다.

list_tags() → list[str]

프로젝트의 모든 고유 태그를 나열합니다. 반환값: 프로젝트의 모든 태그 string을 정렬한 목록입니다.

`function` `log_call`

log_call(
    op: 'str',
    inputs: 'dict[str, Any]',
    output: 'Any',
    parent: 'Call | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    display_name: 'str | Callable[[Call], str] | None' = None,
    use_stack: 'bool' = True,
    exception: 'BaseException | None' = None
) → Call

데코레이터 패턴을 사용하지 않고 Call을 Weave에 직접 로깅합니다. 이 함수는 Weave에 오퍼레이션을 로깅하는 명령형 API를 제공합니다. 이미 실행된 Call을 나중에 로깅하려는 경우나 데코레이터 패턴이 사용 사례에 맞지 않는 경우에 유용합니다. 인수:

op (str): 로깅할 오퍼레이션 이름입니다. Call의 op_name으로 사용됩니다. 익명 오퍼레이션(게시된 Op를 참조하지 않는 string)도 지원됩니다.
inputs (dict[str, Any]): 오퍼레이션의 입력 매개변수 딕셔너리입니다.
output (Any): 오퍼레이션의 출력/결과입니다.
parent (Call | None): 이 Call을 중첩할 부모 Call입니다(선택). 지정하지 않으면 루트 수준 Call이 됩니다(현재 Call 컨텍스트가 있으면 해당 Call 아래에 중첩됨). 기본값은 None입니다.
attributes (dict[str, Any] | None): Call에 첨부할 메타데이터입니다(선택). Call이 생성된 후에는 변경할 수 없습니다. 기본값은 None입니다.
display_name (str | Callable[[Call], str] | None): UI에 표시할 Call의 표시 이름입니다(선택). string 또는 Call을 받아 string을 반환하는 callable을 지정할 수 있습니다. 기본값은 None입니다.
use_stack (bool): Call을 런타임 스택에 푸시할지 여부입니다. True이면 Call 컨텍스트에서 Call을 사용할 수 있으며 weave.require_current_call()로 액세스할 수 있습니다. False이면 Call은 로깅되지만 호출 스택에는 추가되지 않습니다. 기본값은 True입니다.
exception (BaseException | None): 오퍼레이션이 실패한 경우 로깅할 예외입니다(선택). 기본값은 None입니다.

반환값:

Call: 전체 트레이스 정보가 포함된, 생성 및 완료된 Call 객체입니다.

예시: 기본 사용법:

import weave
    >>> weave.init('my-project')
    >>> call = weave.log_call(
    ...     op="my_function",
    ...     inputs={"x": 5, "y": 10},
    ...     output=15
    ... )

    Logging with attributes and display name:
    >>> call = weave.log_call(
    ...     op="process_data",
    ...     inputs={"data": [1, 2, 3]},
    ...     output={"mean": 2.0},
    ...     attributes={"version": "1.0", "env": "prod"},
    ...     display_name="Data Processing"
    ... )

    Logging a failed operation:
    >>> try:
    ...     result = risky_operation()
    ... except Exception as e:
    ...     call = weave.log_call(
    ...         op="risky_operation",
    ...         inputs={},
    ...         output=None,
    ...         exception=e
    ...     )

    Nesting calls:
    >>> parent_call = weave.log_call("parent", {"input": 1}, 2)
    >>> child_call = weave.log_call(
    ...     "child",
    ...     {"input": 2},
    ...     4,
    ...     parent=parent_call
    ... )

    Logging without adding to call stack:
    >>> call = weave.log_call(
    ...     op="background_task",
    ...     inputs={"task_id": 123},
    ...     output="completed",
    ...     use_stack=False  # 호출 스택에 추가하지 않음
    ... )

---

<SourceLink url="https://github.com/wandb/weave/blob/v0.53.1/weave/conversation/conversation.py#L1584" />

### <kbd>function</kbd> `log_conversation`

```python
log_conversation(
    turns: 'list[Turn]',
    conversation_id: 'str' = '',
    conversation_name: 'str' = '',
    agent_name: 'str' = '',
    model: 'str' = '',
    agent_id: 'str' = '',
    agent_description: 'str' = '',
    agent_version: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

완전한 대화를 명령형 방식으로 내보냅니다. 각 Turn의 하위 항목은 해당 Turn의 .spans 속성으로 제공됩니다. conversation_id가 비어 있으면 자동으로 생성됩니다. 기본적으로 각 turn은 별도의 OTel 트레이스를 갖습니다. agent_name / model / agent_id / agent_description / agent_version은 대화 수준의 기본값입니다. Turn에 자체 값이 있으면 그 값이 우선하며, 대화 수준의 값은 Turn에서 해당 값을 비워 둔 경우에만 사용됩니다. 대화의 continue_parent_trace는 모든 turn에 적용됩니다(Turn별 continue_parent_trace는 여기서 의도적으로 무시됩니다). attributes는 내보내는 모든 span에 기록됩니다. semconv가 아닌 맞춤형 키를 사용하세요. span 자체의 gen_ai.* / weave.* 속성과 충돌하는 키는 지원되지 않습니다(어느 값이 우선할지는 경로에 따라 달라집니다).

`function` `log_session`

log_session(
    turns: 'list[Turn]',
    session_id: 'str' = '',
    session_name: 'str' = '',
    agent_name: 'str' = '',
    model: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

:func:weave.log_conversation의 사용 중단된 별칭입니다. session_id / session_name은 각각 conversation_id / conversation_name에 매핑됩니다.

`function` `log_turn`

log_turn(
    conversation_id: 'str',
    agent_name: 'str' = '',
    conversation_name: 'str' = '',
    model: 'str' = '',
    agent_id: 'str' = '',
    agent_description: 'str' = '',
    agent_version: 'str' = '',
    messages: 'list[Message] | None' = None,
    system_instructions: 'list[str] | None' = None,
    spans: 'list[LLM | Tool | SubAgent] | None' = None,
    started_at: 'datetime | None' = None,
    ended_at: 'datetime | None' = None,
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → LogResult

turn 하나와 그 하위 span을 명령형 방식으로 OTel에 내보냅니다. context manager를 사용할 수 없는 경우(상태를 유지하지 않는 컨테이너, callback, 큐 워커)에 사용하세요. 전달하는 각 하위 span에는 started_at / ended_at이 설정되어 있어야 하며, 내보내는 OTel span의 타임스탬프는 이 필드 값을 따릅니다. turn에 자체 타임스탬프가 없으면 하위 span 중 가장 이른/가장 늦은 타임스탬프를 사용하고, 이마저 없으면 now()를 사용합니다. agent_id / agent_description / agent_version은 스트리밍 경로와 동일하게 동작합니다. attributes는 내보내는 모든 span에 기록됩니다. 스트리밍 경로에서는 이 값을 활성 대화에서 대신 읽어 옵니다. semconv가 아닌 맞춤형 키를 사용하세요. span 자체의 gen_ai.* / weave.* 속성과 충돌하는 키는 지원되지 않습니다(어느 값이 적용될지는 경로에 따라 다릅니다).

`function` `op`

op(
    func: 'Callable[P, R] | None' = None,
    name: 'str | None' = None,
    call_display_name: 'str | CallDisplayNameFunc | None' = None,
    postprocess_inputs: 'PostprocessInputsFunc | None' = None,
    postprocess_output: 'PostprocessOutputFunc | None' = None,
    tracing_sample_rate: 'float' = 1.0,
    enable_code_capture: 'bool' = True,
    accumulator: 'Callable[[Any | None, Any], Any] | None' = None,
    kind: 'OpKind | None' = None,
    color: 'OpColor | None' = None,
    attributes: 'dict[str, Any] | None' = None,
    eager_call_start: 'bool' = False
) → Callable[[Callable[P, R]], Op[P, R]] | Op[P, R]

함수나 메서드를 Weave Op으로 변환하는 데코레이터입니다. 동기 및 비동기 방식을 모두 지원합니다. 이터레이터 함수를 자동으로 감지하여 적절한 동작을 적용합니다. 인수:

`function` `otel_traces_endpoint`

otel_traces_endpoint(base_url: str | None = None) → str

Weave GenAI 트레이스 수집에 사용할 전체 OTLP HTTP 엔드포인트 URL을 반환합니다. 외부 호출자(예: BatchSpanProcessor가 내보내기를 조용히 버리도록 맡기기 전에 수집 엔드포인트에 접근할 수 있는지 확인하려는 부팅 시점 프로브)는 URL을 직접 구성하지 말고 이 함수를 호출해야 합니다. 경로는 SDK가 관리하며 변경될 수 있습니다.

func: 데코레이트할 함수입니다.
name: Op의 맞춤형 이름입니다. 기본값은 함수 이름입니다.
call_display_name: Call의 표시 이름으로, string 또는 callable을 지정할 수 있습니다.
postprocess_inputs: 로깅하기 전에 입력을 변환하는 함수입니다.
postprocess_output: 로깅하기 전에 출력을 변환하는 함수입니다.
tracing_sample_rate: 트레이스할 Call의 비율(0.0~1.0)입니다.
enable_code_capture: 이 Op의 소스 코드를 캡처할지 여부입니다.
accumulator: 스트리밍 Op의 결과를 누적하는 함수입니다.
attributes: 이 Op가 생성하는 모든 Call에 가장 낮은 우선순위로 병합되는 기본 속성입니다. 키가 충돌하면 weave.attributes() 컨텍스트와 명시적으로 지정한 호출별 속성이 우선 적용됩니다. 예약된 “weave” 키는 여기에서 설정할 수 없습니다.
eager_call_start: True이면 Call 시작 정보를 배치로 묶지 않고 즉시 전송합니다. 평가처럼 UI에 바로 표시되어야 하는 장시간 실행 오퍼레이션에 유용합니다. 인수:

`function` `publish`

publish(
    obj: 'Any',
    name: 'str | None' = None,
    tags: 'list[str] | None' = None,
    aliases: 'list[str] | None' = None
) → ObjectRef

Python 객체를 저장하고 버전을 관리합니다. 같은 이름의 객체가 이미 있고 콘텐츠 해시가 해당 객체의 최신 버전과 일치하지 않으면 Weave는 객체의 새 버전을 생성합니다.

base_url: 트레이스 서버의 base URL입니다. 기본값은 weave_trace_server_url()입니다. 인수:
obj: 저장하고 버전을 관리할 객체입니다.
name: 객체를 저장할 이름입니다.
tags: 게시된 객체 버전에 추가할 태그 목록입니다(선택).
aliases: 게시된 객체 버전에 설정할 별칭 목록입니다(선택). 반환값: 저장된 객체를 가리키는 Weave Ref입니다.

`function` `ref`

ref(location: 'str') → ObjectRef

기존 Weave 객체를 가리키는 Ref를 생성합니다. 객체를 직접 가져오지는 않지만, 이 Ref를 다른 Weave API 함수에 전달할 수 있습니다. 인수:

location: Weave Ref URI입니다. weave.init()을 호출한 경우에는 name:version 또는 name을 사용할 수도 있습니다. 버전을 지정하지 않으면 latest가 사용됩니다. 반환값: 객체를 가리키는 Weave Ref입니다.

`function` `remove_aliases`

remove_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

객체에서 하나 이상의 별칭을 제거합니다. 인수:

`function` `remove_tags`

remove_tags(obj_ref: 'ObjectRef | str', tags: 'list[str]') → None

객체 버전에서 태그를 제거합니다.

obj_ref: 객체에 대한 레퍼런스입니다. ObjectRef 또는 weave /// URI string을 지정합니다.
alias: 제거할 별칭 이름 또는 별칭 이름 목록입니다. 인수:

`function` `require_current_call`

require_current_call() → Call

현재 실행 중인 Op 내부에서 해당 Op의 Call 객체를 조회합니다. 이를 통해 Call이 실행되는 동안 id나 feedback 같은 Call의 속성에 액세스할 수 있습니다.

@weave.op
def hello(name: str) -> None:
     print(f"Hello {name}!")
     current_call = weave.require_current_call()
     print(current_call.id)

Op이 반환된 후에도 Call에 액세스할 수 있습니다. UI 등에서 Call의 id를 확인했다면 weave.init이 반환하는 WeaveClient의 get_call 메서드를 사용하여 Call 객체를 조회할 수 있습니다.

client = weave.init("<project>")
mycall = client.get_call("<call_id>")

또는 Op를 정의한 후 해당 Op의 call 메서드를 사용할 수도 있습니다. 예를 들면 다음과 같습니다.

@weave.op
def add(a: int, b: int) -> int:
     return a + b

result, call = add.call(1, 2)
print(call.id)

obj_ref: 객체 버전에 대한 레퍼런스로, ObjectRef 또는 weave /// URI string입니다.
tags: 제거할 태그 string의 목록입니다. 반환값: 현재 실행 중인 Op의 Call 객체입니다.

예외:

NoCurrentCallError: 추적이 초기화되지 않았거나 이 메서드가 Op 외부에서 호출된 경우 발생합니다.

`function` `set_aliases`

set_aliases(obj_ref: 'ObjectRef | str', alias: 'str | list[str]') → None

객체 버전에 별칭을 하나 이상 설정합니다. 인수:

`function` `set_view`

set_view(
    name: 'str',
    content: 'Content | str',
    extension: 'str | None' = None,
    mimetype: 'str | None' = None,
    metadata: 'dict[str, Any] | None' = None,
    encoding: 'str' = 'utf-8'
) → None

현재 call 요약의 _weave.views.<name>에 맞춤형 뷰를 연결합니다.

obj_ref: 객체 버전에 대한 레퍼런스로, ObjectRef 또는 weave /// URI string입니다.
alias: 설정할 별칭 이름 또는 별칭 이름 목록입니다(예: “production”). 인수:
name: 뷰 이름입니다(summary._weave.views 아래의 키).
content: weave.Content 인스턴스 또는 원시 string입니다. string은 지정된 확장자 또는 MIME 유형을 사용해 Content.from_text로 래핑됩니다.
extension: content가 string일 때 사용할 파일 확장자입니다(선택).
mimetype: content가 string일 때 사용할 MIME 유형입니다(선택).
metadata: 텍스트에서 Content를 생성할 때 연결할 메타데이터입니다(선택).
encoding: 텍스트에서 Content를 생성할 때 적용할 텍스트 인코딩입니다. 반환값: None

예시: import weave

weave.init(“proj”) @weave.op … def foo(): … weave.set_view(“readme”, ”# Hello”, extension=“md”) … return 1 foo()

`function` `start_conversation`

start_conversation(
    agent_name: 'str' = '',
    model: 'str' = '',
    conversation_id: 'str' = '',
    conversation_name: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → Conversation

대화를 생성하고 활성화합니다. 모듈 간 액세스가 가능하도록 contextvar를 설정합니다. attributes는 이 대화가 내보내는 모든 span에 기록됩니다(예: weave.integration.*와 같은 인테그레이션 ID). semconv에 해당하지 않는 맞춤형 키를 사용하세요. 시맨틱 규칙(semantic convention) 필드는 유형이 지정된 매개변수(conversation_name, model 등)로 설정하세요. span 자체의 gen_ai.* / weave.* 속성과 충돌하는 키는 지원되지 않으며, 어느 값이 우선 적용되는지는 경로(스트리밍 또는 log_turn)에 따라 달라집니다.

`function` `start_llm`

start_llm(
    model: 'str' = '',
    provider_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → LLM

LLM Call을 생성하고 활성화합니다. 현재 턴이 있으면 해당 턴을 사용합니다. 활성 턴이 없으면 연결되지 않은 LLM을 반환합니다(contextvar가 설정되지 않음). provider_name을 명시적으로 전달하세요. SDK는 모델 식별자에서 공급자를 추론하지 않습니다. 접두사 기반으로 추측하면 사용자가 파인튜닝한 모델(예: 이름이 text-...인 모델)의 공급자를 잘못 판별하게 되고, 향후 모델 이름에 대한 가정이 telemetry에 그대로 반영됩니다. 이러한 데이터는 나중에 바로잡으려면 많은 비용이 듭니다.

`function` `start_session`

start_session(
    agent_name: 'str' = '',
    model: 'str' = '',
    session_id: 'str' = '',
    session_name: 'str' = '',
    include_content: 'bool' = True,
    continue_parent_trace: 'bool' = False,
    attributes: 'Attributes' = None
) → Conversation

:func:weave.start_conversation의 사용 중단된 별칭입니다. session_id / session_name은 각각 conversation_id / conversation_name에 매핑됩니다.

`function` `start_subagent`

start_subagent(
    name: 'str',
    model: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → SubAgent

하위 에이전트 호출 span을 생성합니다. SubAgent의 OTel span은 OTel 컨텍스트에서 현재 span의 자식으로 자동 설정되며, 일반적으로 활성 상태인 Turn span이 있으면 해당 span의 자식이 됩니다. 구조는 start_tool과 동일합니다. 부모-자식 관계 전파는 OTel 컨텍스트가 처리하므로 명시적으로 위임할 필요가 없습니다.

`function` `start_tool`

start_tool(name: 'str', arguments: 'str' = '', tool_call_id: 'str' = '') → Tool

도구 실행 span을 생성합니다. Tool의 OTel span은 OTel 컨텍스트에서 현재 활성화된 span의 하위 span이 자동으로 됩니다. 일반적으로 Turn span이 활성 상태라면 해당 Turn span의 하위 span이 됩니다. turn 위임을 명시적으로 지정할 필요는 없습니다. 부모-자식 관계는 Conversation SDK의 contextvar가 아니라 OTel 컨텍스트를 통해 전파됩니다.

`function` `start_turn`

start_turn(
    user_message: 'str' = '',
    model: 'str' = '',
    agent_name: 'str' = '',
    system_instructions: 'list[str] | None' = None
) → Turn

턴을 생성하고 활성화합니다. 현재 대화가 있으면 해당 대화를 사용합니다. 활성 대화가 없으면 contextvar에 설정되지 않은, 연결되지 않은 Turn을 반환합니다. 따라서 get_current_turn()은 None을 반환합니다. contextvar 기반의 모듈 간 액세스가 필요하다면 conversation.start_turn()을 대신 사용하세요.

`function` `thread`

thread(
    thread_id: 'str | object | None' = <object object at 0x7f136d9f4bd0>
) → Iterator[ThreadContext]

컨텍스트 내 Call에 thread_id를 설정하는 컨텍스트 관리자입니다. 예시:

# thread_id 자동 생성
with weave.thread() as t:
     print(f"Thread ID: {t.thread_id}")
     result = my_function("input")  # 이 호출에는 자동 생성된 thread_id가 설정됩니다
     print(f"Current turn: {t.turn_id}")

# thread_id 명시적 지정
with weave.thread("custom_thread") as t:
     result = my_function("input")  # 이 호출에는 thread_id="custom_thread"가 설정됩니다

# 스레드 추적 비활성화
with weave.thread(None) as t:
     result = my_function("input")  # 이 호출에는 thread_id=None이 설정됩니다

인수:

thread_id: 이 컨텍스트의 Call과 연결할 스레드 식별자입니다. 지정하지 않으면 UUID v7이 자동으로 생성됩니다. None이면 스레드 추적이 비활성화됩니다. Yields:
ThreadContext: thread_id 및 현재 turn_id에 액세스할 수 있는 객체입니다.

`function` `wandb_init_hook`

wandb_init_hook() → None

마지막 수정일 2026년 9월 30일

​API 개요

​class Agent

​method step

​class AgentState

​class AnnotationSpec

​클래스 메서드 preprocess_field_schema

​클래스 메서드 validate_field_schema

​method value_is_valid

​클래스 Audio

​method __init__

​method export

​클래스 메서드 from_data

​클래스 메서드 from_path

​class ClassifierMonitor

​method activate

​method deactivate

​클래스 메서드 from_obj

​method get_prompt_footer

​method get_prompt_header

​method model_post_init

​class Content

​method __init__

​property art

​property ref

​방법 as_string

​클래스 메서드 from_base64

​클래스 메서드 from_bytes

​클래스 메서드 from_data_url

​클래스 메서드 from_path

​클래스 메서드 from_text

​클래스 메서드 from_url

​클래스 메서드 model_validate

​클래스 메서드 model_validate_json

​method open

​method save

​method serialize_data

​방법 to_data_url

​class Conversation

​method end

​method model_post_init

​method start_turn

​class Dataset

​method add_rows

​클래스 메서드 convert_to_table

​클래스 메서드 from_calls

​클래스 메서드 from_hf

​클래스 메서드 from_obj

​클래스 메서드 from_pandas

​method select

​method to_hf

​method to_pandas

​클래스 EasyPrompt

​method __init__

​property as_str

​property is_bound

​property messages

​property placeholders

​property system_message

​property system_prompt

​property unbound_placeholders

​method append

​method as_dict

​method as_pydantic_dict

​method bind

​method bind_rows

​method config_table

​method configure

​method dump

​method dump_file

​method format

​클래스 메서드 from_obj

​클래스 메서드 load

​클래스 메서드 load_file

​method messages_table

​method print

​method publish

​method require

​method run

​method validate_requirement

​method validate_requirements

API 개요

`class` `Agent`

`method` `step`

`class` `AgentState`

`class` `AnnotationSpec`

`클래스 메서드` `preprocess_field_schema`

`클래스 메서드` `validate_field_schema`

`method` `value_is_valid`

`클래스` `Audio`

`method` `init`

`method` `export`

`클래스 메서드` `from_data`

`클래스 메서드` `from_path`

`class` `ClassifierMonitor`

`method` `activate`

`method` `deactivate`

`클래스 메서드` `from_obj`

`method` `get_prompt_footer`

`method` `get_prompt_header`

`method` `model_post_init`

`class` `Content`

`method` `init`

`property` art

`property` ref

`방법` `as_string`

`클래스 메서드` `from_base64`

`클래스 메서드` `from_bytes`

`클래스 메서드` `from_data_url`

`클래스 메서드` `from_path`

`클래스 메서드` `from_text`

`클래스 메서드` `from_url`

`클래스 메서드` `model_validate`

`클래스 메서드` `model_validate_json`

`method` `open`

`method` `save`

`method` `serialize_data`

`방법` `to_data_url`

`class` `Conversation`

`method` `end`

`method` `model_post_init`

`method` `start_turn`

`class` `Dataset`

`method` `add_rows`

`클래스 메서드` `convert_to_table`

`클래스 메서드` `from_calls`

`클래스 메서드` `from_hf`

`클래스 메서드` `from_obj`

`클래스 메서드` `from_pandas`

`method` `select`

`method` `to_hf`

`method` `to_pandas`

`클래스` `EasyPrompt`

`method` `init`

`property` as_str

`property` is_bound

`property` messages

`property` placeholders

`property` system_message

`property` system_prompt

`property` unbound_placeholders

`method` `append`

`method` `as_dict`

`method` `as_pydantic_dict`

`method` `bind`

`method` `bind_rows`

`method` `config_table`

`method` `configure`

`method` `dump`

`method` `dump_file`

`method` `format`

`클래스 메서드` `from_obj`

`클래스 메서드` `load`

`클래스 메서드` `load_file`

`method` `messages_table`

`method` `print`

`method` `publish`

`method` `require`

`method` `run`

`method` `validate_requirement`

`method` `validate_requirements`