API Overview

`class` `Agent`

Pydantic 필드:

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]

`방법` `step`

step(state: AgentState) → AgentState

에이전트의 step을 수행합니다. 매개변수:

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

`class` `AgentState`

Pydantic 필드:

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

`class` `AnnotationSpec`

Pydantic 필드:

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]

`방법` `value_is_valid`

value_is_valid(payload: Any) → bool

페이로드가 이 annotation spec의 스키마에 맞는지 검증합니다. 매개변수:

payload: 스키마를 기준으로 검증할 데이터 반환값:
bool: 검증에 성공하면 True, 그렇지 않으면 False

`class` `Audio`

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

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

매개변수:

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

`방법` `init`

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

`방법` `export`

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

오디오 데이터를 파일로 저장합니다. 매개변수:

`클래스 메서드` `from_data`

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

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

path: 오디오 파일을 저장할 경로 매개변수:
data: 바이트 또는 base64로 인코딩된 문자열 형태의 오디오 데이터
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의 프롬프트를 하나의 점수화 call로 결합합니다. Pydantic 필드:

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

`방법` `activate`

activate() → ObjectRef

모니터를 활성화합니다. 반환값: 모니터에 대한 참조입니다.

`방법` `deactivate`

deactivate() → ObjectRef

모니터를 비활성화합니다. 반환값: 모니터에 대한 참조입니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`방법` `get_prompt_footer`

get_prompt_footer() → str

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

`방법` `get_prompt_header`

get_prompt_header(op_name: str) → str

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

`방법` `model_post_init`

model_post_init(context: Any) → None

클라이언트를 사용할 수 있으면 생성 시점에 op_names를 정규화합니다. 게시에는 객체별 훅이 없으므로, 단순히 weave.publish(monitor)만 호출하는 경우(activate() 없음)까지 처리할 수 있도록 여기서 짧은 이름을 확장합니다. 게시하는 쪽은 일반적으로 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()

`방법` `init`

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

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

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

`속성` art

`속성` ref

`방법` `as_string`

as_string() → str

데이터를 문자열로 표시합니다. 바이트는 encoding 속성을 사용해 디코딩합니다. base64인 경우, 데이터를 먼저 base64 바이트로 다시 인코딩한 다음 ASCII 문자열로 디코딩합니다. 반환값: 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로 인코딩된 문자열 또는 바이트에서 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을 재정의합니다.

`방법` `open`

open() → bool

운영 체제의 기본 애플리케이션을 사용하여 파일을 엽니다. 이 방법은 파일 유형과 연결된 기본 애플리케이션으로 파일을 열기 위해 플랫폼별 메커니즘을 사용합니다. 반환값:

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

`방법` `save`

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

파일을 지정된 대상 경로로 복사합니다. 마지막으로 저장된 복사본을 기준으로 콘텐츠의 파일명과 경로를 업데이트합니다. 매개변수:

`방법` `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 문자열입니다.

`class` `Conversation`

대화입니다. conversation_id를 기준으로 turn을 그룹화합니다(span 없음). continue_parent_trace는 이 대화가 생성하는 turn의 트레이스 격리 여부를 제어합니다. 기본값 False는 각 turn이 자체 OTel 트레이스를 시작한다는 의미입니다(독립형 Agents 탭 뷰에 적합한 선택). 애플리케이션에 에이전트 호출을 포함해야 하는 외부 트레이스(예: fastapi-instrumented request)가 있는 경우에는 True로 설정하세요. Pydantic 필드:

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]

`방법` `end`

end() → None

`방법` `model_post_init`

model_post_init(context: 'Any') → None

`방법` `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이 아직 열려 있으면 자동으로 종료합니다. 컨텍스트 관리자 사용 여부와 관계없이 get_current_turn()를 통해 turn이 표시되도록 _current_turn contextvar를 설정합니다. 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 필드:

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

`방법` `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

`방법` `select`

select(indices: Iterable[int]) → Self

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

indices: 선택할 행을 지정하는 정수 인덱스의 이터러블입니다. 반환값: 선택한 행만 포함하는 새 데이터셋 객체입니다.

`방법` `to_hf`

to_hf() → HFDataset

`방법` `to_pandas`

to_pandas() → DataFrame

`class` `EasyPrompt`

`방법` `init`

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

Pydantic 필드:

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

`속성` as_str

모든 메시지를 하나의 문자열로 합쳐 반환합니다.

`속성` is_bound

`속성` 메시지

`속성` 플레이스홀더

`속성` system_message

모든 메시지를 합쳐 하나의 system prompt 메시지로 만듭니다.

`속성` system_prompt

모든 메시지를 시스템 프롬프트 객체로 합칩니다.

`속성` unbound_placeholders

`방법` `append`

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

`방법` `as_dict`

as_dict() → dict[str, Any]

`방법` `as_pydantic_dict`

as_pydantic_dict() → dict[str, Any]

`방법` `bind`

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

`방법` `bind_rows`

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

`방법` `config_table`

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

`방법` `configure`

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

`방법` `dump`

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

`방법` `dump_file`

dump_file(filepath: str | Path) → None

`방법` `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

`방법` `messages_table`

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

`방법` `print`

print() → str

`방법` `publish`

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

`방법` `require`

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

`방법` `run`

run() → Any

`방법` `validate_requirement`

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

`방법` `validate_requirements`

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

`방법` `values_table`

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

`class` `Evaluation`

scorer 집합과 데이터셋을 포함하는 Evaluation을 설정합니다. 평가.evaluate(model)을 호출하면 데이터셋의 각 행이 모델에 전달되며, 이때 데이터셋의 column 이름이 model.predict의 argument 이름과 일치하도록 매핑됩니다. 그런 다음 모든 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"},
]

# 맞춤형 scoring 함수 정의
@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 호출을 추가하고 출력을 반환하는 부분입니다
     return  {'generated_text': 'Paris'}

# scoring 함수를 사용하여 예시 채점
evaluation = Evaluation(
     dataset=examples, scorers=[match_score1]
)

# 평가 tracking 시작
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

`방법` `evaluate`

evaluate(model: Op | Model) → dict

`클래스 방법` `from_obj`

from_obj(obj: WeaveObject) → Self

`방법` `get_eval_results`

get_eval_results(model: Op | Model) → EvaluationResults

`방법` `get_evaluate_calls`

get_evaluate_calls() → PaginatedIterator[CallSchema, WeaveObject]

이 Evaluation 객체를 사용한 모든 평가 call을 조회합니다. 단일 평가에 대해 여러 평가 call이 있을 수 있으므로(예: 동일한 평가을 여러 번 run한 경우), 단일 Call이 아니라 CallsIter를 반환합니다. 반환값:

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

예외:

ValueError: 평가에 ref가 없는 경우(아직 저장되거나 run되지 않은 경우)

예시:

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}")

`방법` `get_score_calls`

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

각 evaluation run의 scorer call을 트레이스 ID별로 그룹화하여 조회합니다. 반환값:

dict[str, list[Call]]: 트레이스 ID를 scorer Call 객체 목록에 매핑한 딕셔너리입니다. 각 트레이스 ID는 하나의 evaluation 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}")

`방법` `get_scores`

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

평가 run의 scorer 출력을 추출해 정리합니다. 반환값:

dict[str, dict[str, list[Any]]]: 다음과 같은 중첩 딕셔너리 구조입니다.
- 첫 번째 수준의 키는 트레이스 ID(평가 run)입니다.
- 두 번째 수준의 키는 scorer 이름입니다.
- 값은 해당 run 및 scorer에 대한 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}]
     }
}

`방법` `model_post_init`

model_post_init(context: Any) → None

`방법` `predict_and_score`

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

`방법` `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 calls)은 자동으로
     # predict call의 하위 항목이 됩니다
     response = your_llm_call(...)
     pred.output = response.content
     pred.log_score("correctness", 0.9)

# 평가를 완료합니다
ev.log_summary({"avg_score": 0.9})

`방법` `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

`속성` attributes

`속성` ui_url

`방법` `fail`

fail(exception: 'BaseException') → None

예외를 발생시켜 평가를 실패 처리하는 편의 방법입니다.

`방법` `finish`

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

summary를 로깅하지 않고 평가 리소스를 명시적으로 정리합니다. 모든 prediction call과 주 평가 call이 최종 처리되도록 보장합니다. logger를 컨텍스트 관리자로 사용하는 경우 이 메서드는 자동으로 호출됩니다.

`방법` `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}
)

`방법` `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()가 자동으로 호출됩니다

`방법` `log_summary`

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

Evaluation에 summary 딕셔너리를 로깅합니다. 이 작업을 수행하면 summary를 계산하고 summarize op를 호출한 뒤 Evaluation을 종료하므로, 이후에는 predictions나 점수를 더 이상 로깅할 수 없습니다.

`방법` `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

weave.views 아래의 evaluation 기본 call 요약에 뷰를 연결합니다. 제공된 콘텐츠를 프로젝트의 객체로 저장하고, evaluation의 evaluate call에 대해 그 레퍼런스 URI를 summary.weave.views.<name> 아래에 기록합니다. 문자열 입력은 제공된 확장자 또는 MIME 유형을 사용해 Content.from_text로 텍스트 콘텐츠로 래핑됩니다. 인수:

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

예시: import weave

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

`class` `File`

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

`방법` `init`

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

File 객체를 초기화합니다. 매개변수:

`속성` filename

파일 이름을 조회합니다.

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

`방법` `open`

open() → bool

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

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

`방법` `save`

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

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

`class` `LLM`

LLM API Call 1건입니다. 채팅 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

`방법` `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 시작과 span 종료 사이(``with`` 내부)에서 호출해야 합니다. 해당 범위 밖에서의 call은 no-op이며 경고를 기록합니다. 

---

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

### <kbd>방법</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 중 정확히 하나만 제공해야 합니다. 게시 작업(미디어 업로드)은 전용 백그라운드 스레드에서 실행되므로 호출자를 차단하지 않고 call이 즉시 반환됩니다. 각 첨부마다 스레드 하나가 디스패치되므로 여러 업로드가 병렬로 진행됩니다. 플레이스홀더 MediaAttachment는 동기적으로 추가되며, 업로드가 완료되면 해당 ref가 채워집니다. span이 emit되기 전에 ref가 채워지는 것은 보장됩니다(build 경로는 _await_uploads를 통해 진행 중인 업로드를 기다립니다).

`방법` `attach_media_url`

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

이 LLM Call에 미디어 URL을 첨부합니다. 호출자에게 업스트림 메시지에서 받은 URL string이 있는 일반적인 경우에는 attach_media보다 더 편리합니다. data: URL은 바이트로 파싱되어 게시되며, 일반 URI는 가져와서 게시됩니다. 빈 URL은 무시됩니다. 체이닝할 수 있도록 self를 반환합니다.

`방법` `end`

end() → None

`방법` `model_post_init`

model_post_init(context: 'Any') → None

`방법` `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

한 번의 Call로 여러 LLM Call 필드를 설정합니다. 수동으로 계측한 에이전트는 일반적으로 LLM Call이 끝날 때 여덟 개 이상의 개별 필드(input_messages, output_messages, usage, response_id 등)에 값을 설정해 채팅 span을 구성합니다. record(...)는 이를 하나의 키워드 Call로 묶어 기록하는 코드를 간결하게 유지합니다. 명시적으로 전달된 필드(non-None)만 적용되며, 기존 값은 유지됩니다. reasoning은 Reasoning 인스턴스 또는 일반 string을 받을 수 있으며(자동으로 래핑됨), 체이닝할 수 있도록 self를 반환합니다.

`방법` `set_attributes`

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

이 span에 임의의 OTel 속성을 설정합니다. 키가 하나이든 여러 개이든 dict를 전달하세요. 키가 하나만 있는 경우에는 span.set_attributes({"weave.tag": "value"})를 사용합니다. OTel의 Span.set_attributes와 동일한 방식입니다. span 시작과 종료 사이, 즉 with 블록 내부에서 호출해야 합니다. 이 구간을 벗어나 호출하면 아무 작업도 수행하지 않으며 경고를 기록합니다. batch ingest의 경우 객체에 선언된 필드를 직접 채운 뒤 log_turn / log_conversation에 전달하세요.

`방법` `think`

think(content: 'str') → LLM

추론/사고 과정 내용을 설정합니다.

`class` `LogResult`

배치 log_* Call 결과입니다. Pydantic 필드:

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

`class` `Markdown`

렌더링할 수 있는 Markdown입니다. 매개변수:

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

`방법` `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, optional): 인라인 코드 강조가 활성화된 경우 사용할 렉서입니다. 기본값은 None입니다.
inline_code_theme: (Optional[str], optional): 인라인 코드 강조에 사용할 Pygments 테마이며, 강조를 사용하지 않으려면 None으로 설정합니다. 기본값은 None입니다. Pydantic 필드:
ref: <class 'str'>
modality: <class 'str'>
mime_type: <class 'str'>

`class` `Message`

대화에서 사용하는 단일 메시지입니다. 두 가지 생성 방식이 지원됩니다.

Flat(이전 버전과의 호환성을 위한 방식으로, 일반 텍스트에 사용하기 편리): Message(role="assistant", content="Hi there")
명시적 parts(더 풍부한 표현 지원 — 도구 Call, 추론+텍스트 혼합, 인라인 미디어): Message(role="assistant", parts=[TextPart(content="Let me check"), ToolCallPart(id="c1", name="get_weather", arguments='{...}')])

parts가 비어 있지 않으면 이것이 표준 표현입니다. 비어 있으면 serializer가 flat 필드에서 단일 TextPart(또는 role="tool"인 경우 ToolCallResponsePart)를 생성합니다. Pydantic 필드:

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

선택적 텍스트와 도구 Call을 포함하는 어시스턴트 메시지를 구축합니다. 단순한 응답에는 일반 텍스트를 사용하고, 어시스턴트가 하나 이상의 도구를 요청하는 경우 tool_calls를 전달하세요. 둘 다 있으면 텍스트가 앞부분의 TextPart로 출력되고, 이어서 각 ToolCallPart가 따라와 채팅 뷰에 인라인으로 렌더링됩니다.

`클래스 메서드` `system`

system(text: 'str') → Message

일반 텍스트로 시스템 메시지를 구축합니다.

`클래스 메서드` `tool_result`

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

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

`클래스 메서드` `user`

user(text: 'str') → Message

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

`class` `MessagesPrompt`

`방법` `init`

__init__(messages: list[dict])

Pydantic 필드:

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

`방법` `format`

format(**kwargs: Any) → list

`방법` `format_message`

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

템플릿 변수를 치환해 단일 메시지를 포맷합니다. 이 방법은 실제 포맷팅 로직을 독립 실행형 format_message_with_template_vars 함수에 위임합니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`class` `Model`

입력을 받아 동작하는 코드와 데이터의 조합을 캡처하기 위한 클래스입니다. 예를 들어, 예측을 수행하거나 텍스트를 생성하기 위해 프롬프트와 함께 LLM을 Call할 수 있습니다. 모델을 정의하는 속성이나 코드를 변경하면 이러한 변경 사항이 로깅되고 버전이 업데이트됩니다. 이를 통해 모델의 서로 다른 버전 간 예측을 비교할 수 있습니다. 이를 사용해 프롬프트를 반복 개선하거나 최신 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 필드:

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

`방법` `get_infer_method`

get_infer_method() → Callable

`class` `Monitor`

수신되는 Call의 점수를 자동으로 매기는 모니터를 설정합니다. op 이름은 Weave 클라이언트의 entity와 프로젝트를 사용해 weave ref로 변환됩니다. 동일한 클라이언트에서 여러 entity와 Projects를 사용하는 경우에는 전체 경로를 포함한 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 필드:

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

`방법` `activate`

activate() → ObjectRef

모니터를 활성화합니다. 반환값: 모니터에 대한 참조입니다.

`방법` `deactivate`

deactivate() → ObjectRef

모니터를 비활성화합니다. 반환값: 모니터에 대한 참조입니다.

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`방법` `model_post_init`

model_post_init(context: Any) → None

클라이언트를 사용할 수 있으면 생성 시점에 op_names를 정규화합니다. Publishing에는 객체별 훅이 없으므로, weave.publish(monitor)를 단독으로 호출하는 경우(activate() 없음)까지 처리할 수 있도록 여기에서 짧은 이름을 확장합니다. publish를 수행하는 사용자는 일반적으로 weave.init를 이미 호출했으므로 monitor가 생성될 때 클라이언트가 설정되어 있습니다. 단위 테스트, 검사, 워커에서 저장된 monitor를 역직렬화하는 경우처럼 클라이언트 없이 생성하는 사용 사례도 여럿 있습니다. get_weave_client()에 가드가 있으므로 클라이언트 없이도 생성할 수 있습니다. 이 경우에는 정규화가 수행되지 않지만, 저장된 monitor에는 이미 전체 ref가 들어 있으므로 괜찮습니다. SDK를 사용할 때 정규화 없이 monitor가 생성될 수 있는 예외적인 경우가 하나 있습니다. 사용자가 monitor를 생성한 다음 weave.init를 호출하고, 그 후 이를 publish하는 경우입니다. 이런 사용 사례에서는 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 필드:

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일 때, 이를 표준 객체 인스턴스로 적절히 변환해야 하는 특수한 경우를 처리합니다. 또한 검증 과정에서 참조가 유지되고, 무시된 유형이 올바르게 처리되도록 보장합니다. 매개변수:

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], …]’ = ())

`방법` `init`

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

`속성` digest

`속성` extra

`속성` is_digest_resolved

`방법` `as_param_dict`

as_param_dict() → dict

`방법` `delete`

delete() → None

`방법` `get`

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

`방법` `is_descended_from`

is_descended_from(potential_ancestor: 'ObjectRef') → bool

`방법` `maybe_parse_uri`

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

`방법` `parse_uri`

parse_uri(uri: 'str') → ObjectRef

`방법` `with_attr`

with_attr(attr: 'str') → Self

`방법` `with_extra`

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

`방법` `with_index`

with_index(index: 'int') → Self

`방법` `with_item`

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

`방법` `with_key`

with_key(key: 'str') → Self

`클래스` `Prompt`

Pydantic 필드:

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

`방법` `format`

format(**kwargs: Any) → Any

`클래스` `SavedView`

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

`방법` `init`

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

`속성` entity

`속성` 레이블

`속성` 프로젝트

`속성` view_type

`방법` `add_column`

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

`방법` `add_columns`

add_columns(*columns: 'str') → SavedView

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

`방법` `add_filter`

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

`방법` `add_sort`

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

`방법` `column_index`

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

`방법` `filter_op`

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

`방법` `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

이 저장된 뷰의 필터와 설정에 맞는 calls를 조회합니다.

`방법` `get_known_columns`

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

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

`방법` `get_table_columns`

get_table_columns() → list[TableColumn]

`방법` `hide_column`

hide_column(col_name: 'str') → SavedView

`방법` `insert_column`

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

`클래스 메서드` `load`

load(ref: 'str') → Self

`방법` `page_size`

page_size(page_size: 'int') → SavedView

`방법` `pin_column_left`

pin_column_left(col_name: 'str') → SavedView

`방법` `pin_column_right`

pin_column_right(col_name: 'str') → SavedView

`방법` `remove_column`

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

`방법` `remove_columns`

remove_columns(*columns: 'str') → SavedView

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

`방법` `remove_filter`

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

`방법` `remove_filters`

remove_filters() → SavedView

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

`방법` `rename`

rename(label: 'str') → SavedView

`방법` `rename_column`

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

`방법` `save`

save() → SavedView

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

`방법` `set_columns`

set_columns(*columns: 'str') → SavedView

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

`방법` `show_column`

show_column(col_name: 'str') → SavedView

`방법` `sort_by`

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

`방법` `to_grid`

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

`방법` `to_rich_table_str`

to_rich_table_str() → str

`방법` `ui_url`

ui_url() → str | None

UI에서 이 저장된 뷰를 표시할 URL입니다. 참고로 이는 트레이스 등이 표시되는 “result” 페이지의 URL이며, 뷰 객체의 URL은 아닙니다.

`방법` `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

`속성` display_name

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`방법` `model_post_init`

model_post_init(context: Any) → None

`방법` `score`

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

`방법` `summarize`

summarize(score_rows: list) → dict | None

`클래스` `Session`

:class:weave.Conversation의 사용 중단된 별칭입니다. 이전 session_id / session_name 생성자 필드를 허용하고, 이를 conversation_id / conversation_name에 프록시되는 읽기/쓰기 속성으로도 제공합니다. 기존 Session에서는 이것들이 모델 필드였기 때문에, s.session_id를 조회하거나 s.session_id에 값을 부여하는 기존 코드는 계속 작동합니다.

`방법` `init`

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

Pydantic 필드:

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]

`속성` session_id

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

`속성` session_name

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

`클래스` `StringPrompt`

`방법` `init`

__init__(content: str)

Pydantic 필드:

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

`방법` `format`

format(**kwargs: Any) → str

`클래스 메서드` `from_obj`

from_obj(obj: WeaveObject) → Self

`클래스` `SubAgent`

turn 내에서 위임된 에이전트 호출입니다. 같은 트레이스 내의 중첩된 invoke_agent OTel span에 해당합니다. Pydantic 필드:

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

`방법` `add_event`

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

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

Use for marker / lifecycle data — permission prompts (e.g. ``weave.permission_request``), lifecycle transitions (e.g. ``spawned`` / ``streaming`` / ``finished``), or any custom milestone that happens at a point in time within the span's lifetime (vs an attribute, which is a property of the span as a whole). 

Must be called between span start and span end (inside ``with``). Outside that window the call is a no-op and logs a warning. 

---

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

### <kbd>방법</kbd> `end`

```python
end() → None

`방법` `llm`

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

이 하위 에이전트 내에서 LLM 호출을 시작합니다. _current_llm contextvar를 설정하여 컨텍스트 관리자를 사용하든 사용하지 않든 get_current_llm()를 통해 LLM에 접근할 수 있도록 합니다.

`방법` `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 속성을 업데이트합니다.

`방법` `set_attributes`

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

이 span에 임의의 OTel 속성을 설정합니다. 키가 하나든 여러 개든 dict를 전달하면 됩니다. 키가 하나뿐인 경우에는 span.set_attributes({"weave.tag": "value"})를 사용하세요. OTel의 Span.set_attributes와 동일한 방식입니다. span 시작과 종료 사이, 즉 with 블록 내부에서 호출해야 합니다. 이 범위를 벗어나 호출하면 아무 작업도 수행되지 않으며 경고 로그가 기록됩니다. batch ingest의 경우 객체에 선언된 필드를 직접 채운 뒤 log_turn / log_conversation에 전달하세요.

`방법` `tool`

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

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

`클래스` `Table`

`방법` `init`

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

`속성` 행

`방법` `append`

append(row: 'dict') → None

테이블에 행을 추가합니다.

`방법` `pop`

pop(index: 'int') → None

테이블에서 지정된 인덱스의 행을 제거합니다.

`class` `ContextAwareThread`

호출자 컨텍스트로 함수를 실행하는 스레드입니다. 이 클래스는 스레드 내부에서 Call이 예상대로 동작하도록 보장하는 threading.Thread의 대체 구현입니다. Weave는 특정 contextvars가 설정되어 있어야 하지만(call_context.py 참조), 새 스레드는 부모의 컨텍스트를 자동으로 복사하지 않으므로 Call 컨텍스트가 손실될 수 있습니다 — 바람직하지 않습니다! 이 클래스는 contextvars 복사를 자동화하므로, 이 스레드를 사용하면 사용자가 기대하는 대로 “그냥 동작합니다”. 이 클래스를 사용하지 않고도, 대신 다음과 같이 작성하면 같은 효과를 얻을 수 있습니다:

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()

`방법` `init`

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

`속성` daemon

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

`속성` ident

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

`속성` name

식별 목적으로만 사용되는 문자열입니다. 의미는 없습니다. 여러 스레드에 같은 이름이 부여될 수 있습니다. 초기 이름은 생성자에서 설정됩니다.

`속성` native_id

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

`방법` `run`

run() → None

`class` `ThreadContext`

현재 스레드와 턴 정보에 접근할 수 있는 컨텍스트 객체입니다.

`방법` `init`

__init__(thread_id: 'str | None')

지정한 thread_id로 ThreadContext를 초기화합니다. 매개변수:

`속성` thread_id

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

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

`속성` turn_id

활성 컨텍스트에서 현재 turn_id를 조회합니다. 반환값: 설정된 경우 현재 turn_id를 반환하고, 그렇지 않으면 None을 반환합니다.

`class` `ContextAwareThreadPoolExecutor`

호출자의 컨텍스트로 함수를 실행하는 ThreadPoolExecutor입니다. 이 클래스는 concurrent.futures.ThreadPoolExecutor를 그대로 대체할 수 있으며, executor 내부에서 Weave Calls가 예상대로 동작하도록 보장합니다. Weave는 특정 contextvars가 설정되어 있어야 하지만(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)

`방법` `init`

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

`방법` `map`

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

`방법` `submit`

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

`class` `Tool`

도구 실행 한 건을 나타냅니다. execute_tool OTel span에 매핑됩니다. arguments 및 result는 JSONString annotation을 사용합니다. 호출자는 dict / list / scalar를 부여할 수 있으며, SDK는 생성 시점이나 값 부여 시점에 이를 JSON으로 인코딩합니다. 저장되는 값은 항상 string이며, GenAI semconv의 wire format과 일치합니다. Pydantic 필드:

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

`방법` `add_event`

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

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

Use for marker / lifecycle data — 권한 프롬프트 (e.g. ``weave.permission_request``), lifecycle transitions (e.g. ``spawned`` / ``streaming`` / ``finished``), or any custom milestone that happens at a point in time within the span's lifetime (vs an attribute, which is a property of the span as a whole). 

Must be called between span start and span end (inside ``with``). Outside that window the call is a no-op and logs a warning. 

---

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

### <kbd>방법</kbd> `end`

```python
end() → None

`방법` `set_attributes`

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

`class` `Turn`

사용자와 에이전트가 한 차례 주고받는 상호작용입니다. invoke_agent OTel span에 매핑됩니다. 기본적으로 각 턴은 자체 OTel 트레이스를 시작하므로(continue_parent_trace=False) Agents 탭에는 턴마다 하나의 트레이스가 표시됩니다. 외부 트레이스가 이미 활성화되어 있고 에이전트 호출을 그 안에 중첩하려면 Conversation(또는 Turn에 직접)에서 continue_parent_trace=True를 설정하세요. 예를 들어 fastapi-instrumented request 내부에서 사용하는 경우입니다. Pydantic 필드:

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

`방법` `add_event`

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

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

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

span 시작과 종료 사이(`with` 내부)에서 호출해야 합니다. 이 범위를 벗어나면 호출은 no-op가 되며 경고를 기록합니다. 

---

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

### <kbd>방법</kbd> `end`

```python
end() → None

`방법` `llm`

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

LLM Call을 시작합니다(채팅 span, 이 턴의 하위 span). 컨텍스트 관리자를 사용하는지와 관계없이 get_current_llm()을 통해 LLM을 확인할 수 있도록 _current_llm contextvar를 설정합니다.

`방법` `model_post_init`

model_post_init(context: 'Any') → None

`방법` `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

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

`방법` `set_attributes`

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

`방법` `subagent`

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

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

`방법` `도구`

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

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

`방법` `user`

user(content: 'str') → Turn

턴 중간에 사용자 메시지를 추가합니다.

`class` `Usage`

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

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

`함수` `add_tags`

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

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

`함수` `as_op`

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

@weave.op로 데코레이션된 함수가 주어지면 해당 Op를 반환합니다. @weave.op로 데코레이션된 함수는 이미 Op의 인스턴스이므로, 이 함수는 런타임에 아무 작업도 하지 않습니다. 하지만 OpDef 속성에 타입 안전하게 접근해야 하는 경우 타입 검사기를 만족시키기 위해 이 함수를 사용할 수 있습니다.

obj_ref: 객체 버전에 대한 레퍼런스로, weave.publish()가 반환하는 ObjectRef 또는 weave /// URI 문자열입니다.
tags: 추가할 태그 문자열 목록입니다. 인수:
fn: @weave.op로 데코레이션된 함수입니다. 반환값: 함수의 Op입니다.

`함수` `attributes`

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

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

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

`함수` `end_conversation`

end_conversation() → None

contextvar에서 현재 대화를 종료합니다.

`함수` `end_llm`

end_llm() → None

contextvar의 현재 LLM Call을 종료합니다.

`함수` `end_session`

end_session() → None

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

`함수` `end_turn`

end_turn() → None

contextvar의 현재 턴을 종료합니다.

`함수` `finish`

finish() → None

Weave 로깅을 중지합니다. 종료 후에는 weave.op 데코레이터가 적용된 함수의 call이 더 이상 로깅되지 않습니다. 로깅을 재개하려면 weave.init()를 다시 실행해야 합니다.

`함수` `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과 동일!

`함수` `get_aliases`

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

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

obj_ref: ObjectRef 또는 weave /// URI 문자열로 지정한 객체 버전에 대한 레퍼런스입니다. 반환값: 별칭 문자열 목록입니다.

`함수` `get_client`

get_client() → WeaveClient | None

`함수` `get_current_call`

get_current_call() → Call | None

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

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

`함수` `get_current_conversation`

get_current_conversation() → Conversation | None

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

`함수` `get_current_llm`

get_current_llm() → LLM | None

contextvar에서 활성 상태의 LLM Call을 반환하거나, 없으면 None을 반환합니다.

`함수` `get_current_session`

get_current_session() → Conversation | None

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

`함수` `get_current_turn`

get_current_turn() → Turn | None

contextvar의 활성 턴을 반환하거나, 없으면 None을 반환합니다.

`함수` `get_tags`

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

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

obj_ref: 객체 버전에 대한 레퍼런스입니다. ObjectRef 또는 weave /// URI 문자열일 수 있습니다. 반환값: 태그 문자열의 목록입니다.

`함수` `get_tags_and_aliases`

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

단일 Call로 객체 버전의 태그와 별칭를 모두 조회합니다. 인수:

obj_ref: 객체 버전을 가리키는 레퍼런스입니다. ObjectRef 또는 weave /// URI 문자열일 수 있습니다. 반환값: (태그, 별칭) 튜플입니다. 각 항목은 문자열 목록입니다.

`함수` `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

wandb 프로젝트에 로깅하도록 Weave 추적을 초기화합니다. 로깅은 전역으로 초기화되므로 init의 반환값을 따로 저장해 둘 필요가 없습니다. init 이후에는 weave.op으로 데코레이팅된 함수의 call이 지정된 프로젝트에 로깅됩니다. 인수: 참고: 클라이언트 수준 후처리는 각 op의 자체 후처리 이후에 실행됩니다. 순서는 항상 다음과 같습니다. 1. op별 후처리 2. 클라이언트 수준 후처리

project_name: 로그를 기록할 Weights & Biases 팀과 프로젝트 이름입니다. 팀을 지정하지 않으면 기본 엔터티가 사용됩니다. 기본 엔터티를 확인하거나 업데이트하려면 W&B Models 문서의 User Settings를 참고하세요.
settings: 전반적인 Weave 클라이언트 설정입니다. UserSettings 인스턴스이거나, 다음 키 중 원하는 항목을 포함하는 dict일 수 있습니다(모두 선택 사항). 모든 설정은 접두사 WEAVE_를 사용하는 환경 변수를 통해서도 구성할 수 있습니다(예: WEAVE_DISABLED=true). 사용 가능한 설정: - disabled (bool): 모든 함수의 트레이스를 비활성화합니다. 기본값: False - print_call_link (bool): ops에 대한 Weave UI 링크를 터미널에 출력합니다. 기본값: True - log_level (str): 로그로 남길 정보 유형을 설정합니다(DEBUG, INFO, WARNING, ERROR, CRITICAL). 기본값: INFO - display_viewer (str): Weave가 콘솔에 객체를 표시하는 방식을 제어합니다(auto, rich, print). 기본값: auto - capture_code (bool): 트레이스된 ops의 코드를 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 엔터티 유형입니다. Default: [] - capture_client_info (bool): Python/SDK 버전 정보를 캡처합니다. Default: True - capture_system_info (bool): OS 정보를 캡처합니다. Default: True - client_parallelism (int): 백그라운드 작업용 워커 수입니다. Default: auto - use_server_cache (bool): 서버 응답의 로컬 디스크 캐싱을 활성화합니다. - server_cache_size_limit (int): 바이트 단위 캐시 크기 한도입니다. Default: 1_000_000_000 - server_cache_dir (str): 서버 캐시 디렉터리입니다. Default: temporary - scorers_dir (str): Scorer 모델 checkpoint 디렉터리입니다. Default: ~/.cache/wandb/weave-scorers - max_calls_queue_size (int): 최대 큐 크기입니다(0 = 무제한). Default: 100_000 - retry_max_interval (float): 초 단위 최대 재시도 간격입니다. Default: 300 - retry_max_attempts (int): 최대 재시도 횟수입니다. Default: 3 - enable_disk_fallback (bool): 누락된 항목을 디스크에 기록합니다. Default: True - use_parallel_table_upload (bool): 큰 테이블에 대해 병렬 청크 업로드를 활성화합니다. False이면 테이블은 더 작은 청크로 순차적으로 업로드됩니다.
기본값: True - http_timeout (float): HTTP 요청이 완료될 때까지 기다리는 최대 시간(초)입니다. 여기에는 연결 시간, 데이터 전송 시간, 서버 처리 시간이 포함됩니다. 네트워크가 느리거나 큰 페이로드를 처리하는 경우 값을 늘리세요.
기본값: 30.0 - use_stainless_server (bool): 더 나은 타입 안전성, 자동 재시도, 향상된 오류 처리를 제공하는 Stainless에서 생성한 HTTP 클라이언트를 사용합니다. 이는 실험적 기능이며 향후 버전에서 기본값이 될 수 있습니다.
기본값: False - use_calls_complete (bool): 별도의 시작/종료 Request 대신, 완료된 Call 데이터(시작 및 종료)를 하나의 Request로 일괄 처리하는 최적화된 쓰기 경로를 사용합니다. 이렇게 하면 서버 부하를 줄이고 성능을 개선할 수 있으며, 특히 수명이 짧은 Ops에서 효과적입니다.
기본값: True - use_otel_v2: (bool): OTel을 지원하는 인테그레이션을 해당 OTel 변형을 통해 처리합니다.
기본값: True
autopatch_settings: (사용 중단) autopatch 인테그레이션용 설정입니다. 대신 명시적으로 패칭하세요.
postprocess_inputs: 이 클라이언트에서 트레이스되는 모든 op의 입력에 적용되는 함수입니다.
postprocess_output: 이 클라이언트에서 트레이스한 모든 op의 출력에 적용되는 함수입니다.
attributes: 이 클라이언트에서 생성되는 모든 트레이스에 적용되는 속성 딕셔너리입니다. 반환값: Weave 클라이언트입니다.

`함수` `link_prompt_to_registry`

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

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

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

`함수` `list_aliases`

list_aliases() → list[str]

프로젝트의 모든 고유한 별칭를 나열합니다. 반환값: 프로젝트의 모든 별칭 문자열을 정렬한 목록입니다.

list_tags() → list[str]

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

`함수` `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를 제공합니다. 이미 실행된 후에 calls를 로깅해야 하거나 데코레이터 패턴이 사용 사례에 맞지 않을 때 유용합니다. 인수:

op (str): 로깅할 오퍼레이션 이름입니다. 이 값은 call의 op_name으로 사용됩니다. 익명 오퍼레이션(게시된 ops를 가리키지 않는 문자열)도 지원됩니다.
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에 표시할 이름(선택 사항)입니다. 문자열이거나, call을 받아 문자열을 반환하는 callable일 수 있습니다. 기본값은 None입니다.
use_stack (bool): call을 런타임 스택에 푸시할지 여부입니다. True이면 call을 call 컨텍스트에서 사용할 수 있으며 weave.require_current_call()을 통해 접근할 수 있습니다. False이면 call은 로깅되지만 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  # call 스택에 푸시하지 않음
    ... )

---

<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의 .spans 속성은 해당 Turn의 하위 항목을 제공합니다. conversation_id가 비어 있으면 자동으로 생성됩니다. 기본적으로 각 턴에는 자체 OTel 트레이스가 할당됩니다. agent_name / model / agent_id / agent_description / agent_version은 대화 수준 기본값입니다. Turn 자체 값이 우선하며, Turn에서 해당 값을 비워 둔 경우에만 대화 값이 채워집니다. 대화의 continue_parent_trace는 모든 턴에 적용됩니다(개별 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에 매핑됩니다.

`함수` `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

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

`함수` `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로 변환하는 데코레이터입니다. 동기와 비동기 모두에서 작동합니다. 이터레이터 함수를 자동으로 감지해 적절한 동작을 적용합니다. 인수:

`함수` `otel_traces_endpoint`

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

Weave GenAI 트레이스 수집을 위한 전체 OTLP HTTP 엔드포인트 URL을 반환합니다. 외부 호출자(예: BatchSpanProcessor가 export를 자동으로 삭제하는 동작에 의존하기 전에 수집 엔드포인트에 도달할 수 있는지 확인하려는 부팅 시점 프로브)는 URL을 직접 구성하지 말고 이것을 호출해야 합니다. 경로는 SDK가 관리하며 변경될 수 있습니다.

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

`함수` `publish`

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

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

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

`함수` `ref`

ref(location: 'str') → ObjectRef

기존 Weave 객체에 대한 Ref를 생성합니다. 객체를 직접 조회하지는 않지만, 다른 Weave API 함수에 전달할 수 있습니다. 인수:

location: Weave Ref URI이거나, weave.init()가 호출된 경우 name:version 또는 name입니다. 버전이 지정되지 않으면 latest를 사용합니다. 반환값: 객체를 가리키는 Weave Ref입니다.

`함수` `remove_aliases`

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

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

`함수` `remove_tags`

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

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

obj_ref: 객체를 가리키는 레퍼런스로, ObjectRef 또는 weave /// URI 문자열일 수 있습니다.
alias: 제거할 별칭 이름 또는 별칭 이름 목록입니다. 인수:

`함수` `require_current_call`

require_current_call() → Call

현재 실행 중인 Op 안에서 해당 Op의 Call 객체를 조회합니다. 이렇게 하면 실행 중인 동안 id나 피드백 같은 Call의 속성에 접근할 수 있습니다.

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

Op가 반환된 후에도 Call에 접근할 수 있습니다. Call의 id가 있다면(예: UI에서 확인한 경우), weave.init가 반환한 WeaveClient의 get_call 방법을 사용해 Call 객체를 조회할 수 있습니다.

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

또는 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 문자열입니다.
tags: 제거할 태그 문자열의 목록입니다. 반환값: 현재 실행 중인 Op의 Call 객체

예외:

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

`함수` `set_aliases`

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

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

`함수` `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 summary의 _weave.views.<name>에 맞춤형 뷰를 추가합니다.

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

예제: import weave

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

`함수` `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의 차이).

`함수` `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에 내장하게 됩니다.

`함수` `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에 대응합니다.

`함수` `start_subagent`

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

하위 에이전트 호출 span을 생성합니다. SubAgent의 OTel span은 OTel 컨텍스트에서 현재 활성 span의 자식으로 자동 설정됩니다. 일반적으로 활성화된 턴 span이 있으면 그 자식 span이 됩니다. 형태는 start_tool과 같으며, 부모-자식 전파는 OTel 컨텍스트가 처리하므로 명시적으로 위임할 필요가 없습니다.

`함수` `start_tool`

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

도구 실행 span을 생성합니다. 도구의 OTel span은 OTel 컨텍스트에서 현재 활성화된 span의 하위 span으로 자동 설정됩니다. 일반적으로 활성화된 턴 span이 있으면 그 하위 span이 됩니다. 턴을 명시적으로 위임할 필요는 없습니다. 부모-자식 전파는 Conversation SDK의 contextvars가 아니라 OTel 컨텍스트를 통해 이루어집니다.

`함수` `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()을 사용하세요.

`함수` `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")  # 이 call에는 자동 생성된 thread_id가 지정됩니다
     print(f"Current turn: {t.turn_id}")

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

# 스레딩 비활성화
with weave.thread(None) as t:
     result = my_function("input")  # 이 call에는 thread_id=None이 지정됩니다

인수:

thread_id: 이 컨텍스트에서 call과 연결할 스레드 식별자입니다. 제공되지 않으면 UUID v7이 자동 생성됩니다. None이면 스레드 추적이 비활성화됩니다. 반환값:
ThreadContext: thread_id와 현재 turn_id에 접근할 수 있는 객체입니다.

`함수` `wandb_init_hook`

wandb_init_hook() → None

​API Overview

​class Agent

​방법 step

​class AgentState

​class AnnotationSpec

​클래스 메서드 preprocess_field_schema

​클래스 메서드 validate_field_schema

​방법 value_is_valid

​class Audio

​방법 __init__

​방법 export

​클래스 메서드 from_data

​클래스 메서드 from_path

​class ClassifierMonitor

​방법 activate

​방법 deactivate

​클래스 메서드 from_obj

​방법 get_prompt_footer

​방법 get_prompt_header

​방법 model_post_init

​class Content

​방법 __init__

​속성 art

​속성 ref

​방법 as_string

​클래스 메서드 from_base64

​클래스 메서드 from_bytes

​클래스 메서드 from_data_url

​클래스 메서드 from_path

​클래스 메서드 from_text

​클래스 메서드 from_url

​클래스 메서드 model_validate

​클래스 메서드 model_validate_json

​방법 open

​방법 save

​방법 serialize_data

​방법 to_data_url

​class Conversation

​방법 end

​방법 model_post_init

​방법 start_turn

​class Dataset

​방법 add_rows

​클래스 메서드 convert_to_table

​클래스 메서드 from_calls

​클래스 메서드 from_hf

​클래스 메서드 from_obj

​클래스 메서드 from_pandas

​방법 select

​방법 to_hf

​방법 to_pandas

​class EasyPrompt

​방법 __init__

​속성 as_str

​속성 is_bound

​속성 메시지

​속성 플레이스홀더

​속성 system_message

​속성 system_prompt

​속성 unbound_placeholders

​방법 append

​방법 as_dict

​방법 as_pydantic_dict

​방법 bind

​방법 bind_rows

​방법 config_table

​방법 configure

​방법 dump

​방법 dump_file

​방법 format

​클래스 메서드 from_obj

​클래스 메서드 load

​클래스 방법 load_file

​방법 messages_table

​방법 print

​방법 publish

​방법 require

​방법 run

​방법 validate_requirement

​방법 validate_requirements

API Overview

`class` `Agent`

`방법` `step`

`class` `AgentState`

`class` `AnnotationSpec`

`클래스 메서드` `preprocess_field_schema`

`클래스 메서드` `validate_field_schema`

`방법` `value_is_valid`

`class` `Audio`

`방법` `init`

`방법` `export`

`클래스 메서드` `from_data`

`클래스 메서드` `from_path`

`class` `ClassifierMonitor`

`방법` `activate`

`방법` `deactivate`

`클래스 메서드` `from_obj`

`방법` `get_prompt_footer`

`방법` `get_prompt_header`

`방법` `model_post_init`

`class` `Content`

`방법` `init`

`속성` art

`속성` ref

`방법` `as_string`

`클래스 메서드` `from_base64`

`클래스 메서드` `from_bytes`

`클래스 메서드` `from_data_url`

`클래스 메서드` `from_path`

`클래스 메서드` `from_text`

`클래스 메서드` `from_url`

`클래스 메서드` `model_validate`

`클래스 메서드` `model_validate_json`

`방법` `open`

`방법` `save`

`방법` `serialize_data`

`방법` `to_data_url`

`class` `Conversation`

`방법` `end`

`방법` `model_post_init`

`방법` `start_turn`

`class` `Dataset`

`방법` `add_rows`

`클래스 메서드` `convert_to_table`

`클래스 메서드` `from_calls`

`클래스 메서드` `from_hf`

`클래스 메서드` `from_obj`

`클래스 메서드` `from_pandas`

`방법` `select`

`방법` `to_hf`

`방법` `to_pandas`

`class` `EasyPrompt`

`방법` `init`

`속성` as_str

`속성` is_bound

`속성` 메시지

`속성` 플레이스홀더

`속성` system_message

`속성` system_prompt

`속성` unbound_placeholders

`방법` `append`

`방법` `as_dict`

`방법` `as_pydantic_dict`

`방법` `bind`

`방법` `bind_rows`

`방법` `config_table`

`방법` `configure`

`방법` `dump`

`방법` `dump_file`

`방법` `format`

`클래스 메서드` `from_obj`

`클래스 메서드` `load`

`클래스 방법` `load_file`

`방법` `messages_table`

`방법` `print`

`방법` `publish`

`방법` `require`

`방법` `run`

`방법` `validate_requirement`

`방법` `validate_requirements`