TensorZero 网关教程

from tensorzero import TensorZeroGateway

with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    result = client.inference(
        function_name="mischievous_chatbot",
        input={
            "system": "You are a friendly but mischievous AI assistant.",
            "messages": [
                {"role": "user", "content": "What is the capital of Japan?"},
            ],
        },
    )

print(result)

import asyncio

from tensorzero import AsyncTensorZeroGateway


async def main():
    async with await AsyncTensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
        result = await client.inference(
            function_name="mischievous_chatbot",
            input={
                "system": "You are a friendly but mischievous AI assistant.",
                "messages": [
                    {"role": "user", "content": "What is the capital of Japan?"},
                ],
            },
        )

    print(result)


if __name__ == "__main__":
    asyncio.run(main())

from openai import OpenAI

with OpenAI(base_url="http://localhost:3000/openai/v1") as client:
    response = client.chat.completions.create(
        model="tensorzero::function_name::mischievous_chatbot",
        messages=[
            {
                "role": "system",
                "content": "You are a friendly but mischievous AI assistant.",
            },
            {
                "role": "user",
                "content": "What is the capital of Japan?",
            },
        ],
    )

print(response)

curl -X POST http://localhost:3000/inference \
  -H "Content-Type: application/json" \
  -d '{
    "function_name": "mischievous_chatbot",
    "input": {
      "system": "You are a friendly but mischievous AI assistant. Your goal is to trick the user.",
      "messages": [
        {
          "role": "user",
          "content": "What is the capital of Japan?"
        }
      ]
    }
  }'

from tensorzero import TensorZeroGateway

with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    inference_result = client.inference(
        function_name="draft_email",
        input={
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "arguments": {
                                "recipient_name": "TensorZero Team",
                                "sender_name": "Mark Zuckerberg",
                                "email_purpose": "Acquire TensorZero for $100 billion dollars.",
                            },
                        }
                    ],
                }
            ],
        },
    )

    # If everything is working correctly, the `variant_name` field should change depending on the request
    print(inference_result)

import asyncio

from tensorzero import AsyncTensorZeroGateway


async def main():
    async with await AsyncTensorZeroGateway.build_http(
        gateway_url="http://localhost:3000"
    ) as client:
        inference_result = await client.inference(
            function_name="draft_email",
            input={
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
                                "arguments": {
                                    "recipient_name": "TensorZero Team",
                                    "sender_name": "Mark Zuckerberg",
                                    "email_purpose": "Acquire TensorZero for $100 billion dollars.",
                                },
                            }
                        ],
                    }
                ],
            },
        )

        # If everything is working correctly, the `variant_name` field should change depending on the request
        print(inference_result)


if __name__ == "__main__":
    asyncio.run(main())

from openai import OpenAI
from tensorzero import TensorZeroGateway

with OpenAI(base_url="http://localhost:3000/openai/v1") as client:
    inference_result = client.chat.completions.create(
        model="tensorzero::function_name::draft_email",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "tensorzero::arguments": {
                            "recipient_name": "TensorZero Team",
                            "sender_name": "Mark Zuckerberg",
                            "email_purpose": "Acquire TensorZero for $100 billion dollars.",
                        },
                    }
                ],
            }
        ],
    )

    print(inference_result)

curl -X POST http://localhost:3000/inference \
  -H "Content-Type: application/json" \
  -d '{
    "function_name": "draft_email",
    "input": {
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "arguments": {
                "recipient_name": "TensorZero Team",
                "sender_name": "Mark Zuckerberg",
                "email_purpose": "Acquire TensorZero for $100 billion dollars."
              }
            }
          ]
        }
      ]
    }
  }'

from tensorzero import TensorZeroGateway

with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    feedback_result = client.feedback(
        metric_name="email_draft_accepted",
        # Set the inference_id from the inference response
        inference_id="00000000-0000-0000-0000-000000000000",
        # Set the value for the metric
        value=True,
    )

    print(feedback_result)

import asyncio

from tensorzero import AsyncTensorZeroGateway


async def main():
    async with await AsyncTensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
        feedback_result = await client.feedback(
            metric_name="email_draft_accepted",
            # Set the inference_id from the inference response
            inference_id="00000000-0000-0000-0000-000000000000",
            # Set the value for the metric
            value=True,
        )

        print(feedback_result)


if __name__ == "__main__":
    asyncio.run(main())

curl -X POST http://localhost:3000/feedback \
  -H "Content-Type: application/json" \
  -d '{
    "metric_name": "email_draft_accepted",
    "inference_id": "00000000-0000-0000-0000-000000000000",
    "value": true
  }'

from tensorzero import TensorZeroGateway, ToolCall

with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    query_result = client.inference(
        function_name="generate_weather_query",
        # This is the first inference request in an episode so we don't need to provide an episode_id
        input={
            "messages": [
                {
                    "role": "user",
                    "content": "What is the weather like in São Paulo?",
                }
            ]
        },
    )

    print(query_result)

    # In a production setting, you'd validate the output more thoroughly
    assert len(query_result.content) == 1
    assert isinstance(query_result.content[0], ToolCall)

    location = query_result.content[0].arguments.get("location")
    units = query_result.content[0].arguments.get("units", "celsius")

    # Now we pretend to make a tool call (e.g. to an API)
    temperature = "35"

    report_result = client.inference(
        function_name="generate_weather_report",
        # This is the second inference request in an episode so we need to provide the episode_id
        episode_id=query_result.episode_id,
        input={
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "arguments": {
                                "location": location,
                                "temperature": temperature,
                                "units": units,
                            },
                        }
                    ],
                }
            ]
        },
    )

    print(report_result)

import asyncio

from tensorzero import AsyncTensorZeroGateway, ToolCall


async def main():
    async with await AsyncTensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
        query_result = await client.inference(
            function_name="generate_weather_query",
            # This is the first inference request in an episode so we don't need to provide an episode_id
            input={
                "messages": [
                    {
                        "role": "user",
                        "content": "What is the weather like in São Paulo?",
                    }
                ]
            },
        )

        print(query_result)

        # In a production setting, you'd validate the output more thoroughly
        assert len(query_result.content) == 1
        assert isinstance(query_result.content[0], ToolCall)

        location = query_result.content[0].arguments.get("location")
        units = query_result.content[0].arguments.get("units", "celsius")

        # Now we pretend to make a tool call (e.g. to an API)
        temperature = "35"

        report_result = await client.inference(
            function_name="generate_weather_report",
            # This is the second inference request in an episode so we need to provide the episode_id
            episode_id=query_result.episode_id,
            input={
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
                                "arguments": {
                                    "location": location,
                                    "temperature": temperature,
                                    "units": units,
                                },
                            }
                        ],
                    }
                ]
            },
        )

        print(report_result)


if __name__ == "__main__":
    asyncio.run(main())

import json

from openai import OpenAI
from tensorzero import TensorZeroGateway

with OpenAI(base_url="http://localhost:3000/openai/v1") as client:
    query_result = client.chat.completions.create(
        model="tensorzero::function_name::generate_weather_query",
        # This is the first inference request in an episode so we don't need to provide an episode_id
        messages=[
            {
                "role": "user",
                "content": "What is the weather like in São Paulo?",
            }
        ],
    )

    print(query_result)

    # In a production setting, you'd validate the output more thoroughly
    assert len(query_result.choices) == 1
    assert query_result.choices[0].message.tool_calls is not None
    assert len(query_result.choices[0].message.tool_calls) == 1
    import json

    tool_call = query_result.choices[0].message.tool_calls[0]
    arguments = json.loads(tool_call.function.arguments)
    location = arguments.get("location")
    units = arguments.get("units", "celsius")

    # Now we pretend to make a tool call (e.g. to an API)
    temperature = "35"

    report_result = client.chat.completions.create(
        model="tensorzero::function_name::generate_weather_report",
        # This is the second inference request in an episode so we need to provide the episode_id
        extra_body={"tensorzero::episode_id": str(query_result.episode_id)},
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "tensorzero::arguments": {
                            "location": location,
                            "temperature": temperature,
                            "units": units,
                        },
                    }
                ],
            }
        ],
    )

    print(report_result)

curl -X POST http://localhost:3000/inference \
  -H "Content-Type: application/json" \
  -d '{
    "function_name": "generate_weather_query",
    "input": {
      "messages": [
        {
          "role": "user",
          "content": "What is the weather like in São Paulo?"
        }
      ]
    }
  }'

curl -X POST http://localhost:3000/inference \
  -H "Content-Type: application/json" \
  -d '{
    "function_name": "generate_weather_report",
    "episode_id": "00000000-0000-0000-0000-000000000000",
    "input": {
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "arguments": {
                "location": "São Paulo",
                "temperature": "35",
                "units": "fahrenheit"
              }
            }
          ]
        }
      ]
    }
  }'

from tensorzero import TensorZeroGateway, ToolCall

with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    feedback_result = client.feedback(
        metric_name="user_rating",
        # Set the episode_id to the one returned in the inference response
        episode_id="00000000-0000-0000-0000-000000000000",
        # Set the value for the metric (numeric types will be coerced to float)
        value=5,
    )

    print(feedback_result)

import asyncio

from tensorzero import AsyncTensorZeroGateway, ToolCall


async def main():
    async with await AsyncTensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
        feedback_result = await client.feedback(
            metric_name="user_rating",
            # Set the episode_id to the one returned in the inference response
            episode_id="00000000-0000-0000-0000-000000000000",
            # Set the value for the metric (numeric types will be coerced to float)
            value=5,
        )

        print(feedback_result)


if __name__ == "__main__":
    asyncio.run(main())

curl -X POST http://localhost:3000/feedback \
  -H "Content-Type: application/json" \
  -d '{
    "metric_name": "user_rating",
    "episode_id": "00000000-0000-0000-0000-000000000000",
    "value": 5
  }'

from tensorzero import TensorZeroGateway


with TensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
    result = client.inference(
        function_name="extract_email",
        input={
            "messages": [
                {
                    "role": "user",
                    "content": "blah blah blah [email protected] blah blah blah",
                }
            ]
        },
    )

    print(result)

import asyncio

from tensorzero import AsyncTensorZeroGateway


async def main():
    async with await AsyncTensorZeroGateway.build_http(gateway_url="http://localhost:3000") as client:
        result = await client.inference(
            function_name="extract_email",
            input={
                "messages": [
                    {
                        "role": "user",
                        "content": "blah blah blah [email protected] blah blah blah",
                    }
                ]
            },
        )

        print(result)


if __name__ == "__main__":
    asyncio.run(main())

from openai import OpenAI


with OpenAI(base_url="http://localhost:3000/openai/v1") as client:
    result = client.chat.completions.create(
        model="tensorzero::function_name::extract_email",
        messages=[
            {
                "role": "user",
                "content": "blah blah blah [email protected] blah blah blah",
            },
        ],
    )

    print(result)

curl -X POST http://localhost:3000/inference \
  -H "Content-Type: application/json" \
  -d '{
    "function_name": "extract_email",
    "input": {
      "messages": [
        {
          "role": "user",
          "content": "blah blah blah [email protected] blah blah blah"
        }
      ]
    }
  }'