Automatikus nyomkövetés

Adjon hozzá egy kódsort a mlflow.<library>.autolog() generatív AI-alkalmazás automatikus nyomon követéséhez. Az automatikus nyomkövetés több mint 20 támogatott kódtárral és keretrendszerrel működik.

Előfeltételek

A Databricks az MLflow 3-at javasolja a legújabb GenAI-nyomkövetési képességekhez.

Futtassa az alábbi parancsokat egy Databricks-jegyzetfüzetben a mlflow csomag és a használni kívánt integrációs csomag telepítéséhez. Ez a példa OpenAI-t használ:

MLflow 3

• mlflow[databricks]>=3.1: Alapvető MLflow-funkciók GenAI-funkciókkal és Databricks-kapcsolattal.
• openai>=1.0.0: Csak az egyszerű automatikus nyomkövetési példa ezen a lapon való futtatásához szükséges (ha más LLM-szolgáltatókat használ, telepítse helyette a megfelelő SDK-jait).
• További kódtárak: Telepítsen bizonyos kódtárakat a használni kívánt integrációkhoz.

Telepítse az alapvető követelményeket:

%pip install --upgrade "mlflow[databricks]>=3.1" openai>=1.0.0
# Also install libraries you want to trace (langchain, anthropic, etc.)

dbutils.library.restartPython()

MLflow 2.x

• mlflow[databricks]>=2.15.0,3.0.0<: Alapvető MLflow-funkciók a Databricks-kapcsolattal.
• openai>=1.0.0: Csak az egyszerű automatikus nyomkövetési példa ezen a lapon való futtatásához szükséges (ha más LLM-szolgáltatókat használ, telepítse helyette a megfelelő SDK-jait).
• További kódtárak: Telepítsen bizonyos kódtárakat a használni kívánt integrációkhoz.

Telepítse az alapvető követelményeket:

%pip install --upgrade "mlflow[databricks]>=2.15.0,<3.0.0" openai>=1.0.0
# Also install libraries you want to trace (langchain, anthropic, etc.)

dbutils.library.restartPython()

Hitelesítő adatok konfigurálása

Databricks-jegyzetfüzet

Databricks-jegyzetfüzetekben állítsa be a szükséges LLM API-kulcsokat:

import os
os.environ["OPENAI_API_KEY"] = "your-api-key"

# Add other provider keys as needed
# os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
# os.environ["MISTRAL_API_KEY"] = "your-api-key"

Külső környezet

Ha külső környezetben van, állítsa be a Databricks hitelesítő adatait és az LLM API-kulcsokat:

export DATABRICKS_HOST="https://your-workspace.cloud.databricks.com"
export DATABRICKS_TOKEN="your-databricks-token"



# Add other provider keys as needed
#export OPENAI_API_KEY="your-openai-api-key"
# export ANTHROPIC_API_KEY="your-anthropic-api-key"
# export MISTRAL_API_KEY="your-mistral-api-key"

Példa automatikus nyomkövetésre

Az alábbiakban bemutatjuk, hogyan engedélyezheti az automatikus nyomkövetést a Databricks Foundation model API-jaihoz csatlakozó OpenAI-ügynökök számára.

import mlflow
import os
from openai import OpenAI

# Databricks Foundation Model APIs use Databricks authentication.

mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/databricks-sdk-autolog-example")

# Enable auto-tracing for OpenAI (which will trace Databricks Foundation Model API calls)
mlflow.openai.autolog()

# Create OpenAI client configured for Databricks
client = OpenAI(
    api_key=os.environ.get("DATABRICKS_TOKEN"),
    base_url=f"{os.environ.get('DATABRICKS_HOST')}/serving-endpoints"
)

# Query Llama 4 Maverick using OpenAI client
response = client.chat.completions.create(
    model="databricks-llama-4-maverick",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What are the key features of MLflow Tracing?"}
    ],
    max_tokens=150,
    temperature=0.7
)

print(response.choices[0].message.content)
# Your calls to Databricks Foundation Model APIs are automatically traced!

Teljes Databricks integrációs útmutató

Egyéb népszerű integrációk

Az MLflow automatikusan nyomon követ 20 vagy több támogatott keretrendszert. A legnépszerűbbek a következők:

OpenAI

Az OpenAI automatikus nyomkövetésének engedélyezése az alábbiak szerint lehetséges:

import mlflow
from openai import OpenAI

# Enable automatic tracing
mlflow.openai.autolog()

# Set up tracking
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/tracing-demo")

# Use OpenAI as normal - traces happen automatically
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "What is MLflow Tracing?"}],
    max_tokens=100
)

print(response.choices[0].message.content)
# All OpenAI calls are now traced.

Tekintse meg a Teljes OpenAI integrációs útmutatót.

LangChain

import mlflow
import os

from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# Enabling autolog for LangChain will enable trace logging.
mlflow.langchain.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/langchain-tracing-demo")

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7, max_tokens=1000)

prompt_template = PromptTemplate.from_template(
    "Answer the question as if you are {person}, fully embodying their style, wit, personality, and habits of speech. "
    "Emulate their quirks and mannerisms to the best of your ability, embracing their traits—even if they aren't entirely "
    "constructive or inoffensive. The question is: {question}"
)

chain = prompt_template | llm | StrOutputParser()

# Let's test another call
chain.invoke(
    {
        "person": "Linus Torvalds",
        "question": "Can I just set everyone's access to sudo to make things easier?",
    }
)

Teljes LangChain integrációs útmutató

LangGraph

from typing import Literal

import mlflow

from langchain_core.messages import AIMessage, ToolCall
from langchain_core.outputs import ChatGeneration, ChatResult
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

# Enabling tracing for LangGraph (LangChain)
mlflow.langchain.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/langgraph-tracing-demo")

@tool
def get_weather(city: Literal["nyc", "sf"]):
    """Use this to get weather information."""
    if city == "nyc":
        return "It might be cloudy in nyc"
    elif city == "sf":
        return "It's always sunny in sf"

llm = ChatOpenAI(model="gpt-4o-mini")
tools = [get_weather]
graph = create_react_agent(llm, tools)

# Invoke the graph
result = graph.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf?"}]}
)

Teljes LangGraph integrációs útmutató

Anthrópiai

import anthropic
import mlflow
import os

# Enable auto-tracing for Anthropic
mlflow.anthropic.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/anthropic-tracing-demo")

# Configure your API key.
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

# Use the create method to create new message.
message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude"},
    ],
)

Teljes antropikus integrációs útmutató

DSPy

import dspy
import mlflow

# Enabling tracing for DSPy
mlflow.dspy.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/dspy-tracing-demo")

# Define a simple ChainOfThought model and run it
lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)

# Define a simple summarizer model and run it
class SummarizeSignature(dspy.Signature):
    """Given a passage, generate a summary."""

    passage: str = dspy.InputField(desc="a passage to summarize")
    summary: str = dspy.OutputField(desc="a one-line summary of the passage")

class Summarize(dspy.Module):
    def __init__(self):
        self.summarize = dspy.ChainOfThought(SummarizeSignature)

    def forward(self, passage: str):
        return self.summarize(passage=passage)

summarizer = Summarize()
summarizer(
    passage=(
        "MLflow Tracing is a feature that enhances LLM observability in your Generative AI (GenAI) applications "
        "by capturing detailed information about the execution of your application's services. Tracing provides "
        "a way to record the inputs, outputs, and metadata associated with each intermediate step of a request, "
        "enabling you to easily pinpoint the source of bugs and unexpected behaviors."
    )
)

Teljes DSPy integrációs útmutató

Fekükőzet

import boto3
import mlflow

# Enable auto-tracing for Amazon Bedrock
mlflow.bedrock.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/bedrock-tracing-demo")

# Create a boto3 client for invoking the Bedrock API
bedrock = boto3.client(
    service_name="bedrock-runtime",
    region_name="<REPLACE_WITH_YOUR_AWS_REGION>",
)

# MLflow will log a trace for Bedrock API call
response = bedrock.converse(
    modelId="anthropic.claude-3-5-sonnet-20241022-v2:0",
    messages=[
        {
            "role": "user",
            "content": "Describe the purpose of a 'hello world' program in one line.",
        }
    ],
    inferenceConfig={
        "maxTokens": 512,
        "temperature": 0.1,
        "topP": 0.9,
    },
)

Teljes bedrock integrációs útmutató

AutoGen

import os
from typing import Annotated, Literal

from autogen import ConversableAgent

import mlflow

# Turn on auto tracing for AutoGen
mlflow.autogen.autolog()

# Set up MLflow tracking on Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/autogen-tracing-demo")

# Define a simple multi-agent workflow using AutoGen
config_list = [
    {
        "model": "gpt-4o-mini",
        # Please set your OpenAI API Key to the OPENAI_API_KEY env var before running this example
        "api_key": os.environ.get("OPENAI_API_KEY"),
    }
]

Operator = Literal["+", "-", "*", "/"]

def calculator(a: int, b: int, operator: Annotated[Operator, "operator"]) -> int:
    if operator == "+":
        return a + b
    elif operator == "-":
        return a - b
    elif operator == "*":
        return a * b
    elif operator == "/":
        return int(a / b)
    else:
        raise ValueError("Invalid operator")

# First define the assistant agent that suggests tool calls.
assistant = ConversableAgent(
    name="Assistant",
    system_message="You are a helpful AI assistant. "
    "You can help with simple calculations. "
    "Return 'TERMINATE' when the task is done.",
    llm_config={"config_list": config_list},
)

# The user proxy agent is used for interacting with the assistant agent
# and executes tool calls.
user_proxy = ConversableAgent(
    name="Tool Agent",
    llm_config=False,
    is_termination_msg=lambda msg: msg.get("content") is not None
    and "TERMINATE" in msg["content"],
    human_input_mode="NEVER",
)

# Register the tool signature with the assistant agent.
assistant.register_for_llm(name="calculator", description="A simple calculator")(
    calculator
)
user_proxy.register_for_execution(name="calculator")(calculator)
response = user_proxy.initiate_chat(
    assistant, message="What is (44231 + 13312 / (230 - 20)) * 4?"
)

Teljes AutoGen integrációs útmutató

Több keretrendszer automatikus nyomkövetése

Az automatikus nyomkövetést több keretrendszerhez is használhatja ugyanabban az ügynökben.

Az alábbi kód egyetlen nyomkövetésben egyesíti a közvetlen OpenAI API-hívásokat, a LangChain-láncokat és az egyéni logikát a könnyű hibakeresés és monitorozás érdekében.

%pip install --upgrade langchain langchain-openai

import mlflow
import openai
from mlflow.entities import SpanType
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# Enable auto-tracing for both OpenAI and LangChain
mlflow.openai.autolog()
mlflow.langchain.autolog()

# Create OpenAI client
client = openai.OpenAI()

@mlflow.trace(span_type=SpanType.CHAIN)
def multi_provider_workflow(query: str):
    # First, use OpenAI directly for initial processing
    analysis = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Analyze the query and extract key topics."},
            {"role": "user", "content": query}
        ]
    )
    topics = analysis.choices[0].message.content

    # Then use LangChain for structured processing
    llm = ChatOpenAI(model="gpt-4o-mini")
    prompt = ChatPromptTemplate.from_template(
        "Based on these topics: {topics}\nGenerate a detailed response to: {query}"
    )
    chain = prompt | llm
    response = chain.invoke({"topics": topics, "query": query})

    return response

# Run the function
result = multi_provider_workflow("Explain quantum computing")

Manuális és automatikus nyomkövetés kombinálása

Az @mlflow.trace automatikus nyomkövetéssel egységes nyomkövetéseket hozhat létre a következő forgatókönyvekhez:

• Több LLM-hívás egy munkafolyamatban
• Többügynök rendszerek különböző szolgáltatókkal
• Testreszabott logika LLM-hívások között

import mlflow
import openai
from mlflow.entities import SpanType

mlflow.openai.autolog()

# Create OpenAI client
client = openai.OpenAI()

@mlflow.trace(span_type=SpanType.CHAIN)
def run(question):
    messages = build_messages(question)
    # MLflow automatically generates a span for OpenAI invocation
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        max_tokens=100,
        messages=messages,
    )
    return parse_response(response)


@mlflow.trace
def build_messages(question):
    return [
        {"role": "system", "content": "You are a helpful chatbot."},
        {"role": "user", "content": question},
    ]


@mlflow.trace
def parse_response(response):
    return response.choices[0].message.content


run("What is MLflow?")

A kód futtatása egyetlen nyomkövetést hoz létre, amely egyesíti a manuális időtartamokat az automatikus OpenAI-nyomkövetéssel:

Speciális példa: több LLM-hívás

import mlflow
import openai
from mlflow.entities import SpanType

# Enable auto-tracing for OpenAI
mlflow.openai.autolog()

# Create OpenAI client
client = openai.OpenAI()

@mlflow.trace(span_type=SpanType.CHAIN)
def process_user_query(query: str):
    # First LLM call: Analyze the query
    analysis = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Analyze the user's query and determine if it requires factual information or creative writing."},
            {"role": "user", "content": query}
        ]
    )
    analysis_result = analysis.choices[0].message.content

    # Second LLM call: Generate response based on analysis
    if "factual" in analysis_result.lower():
        # Use a different model for factual queries
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "Provide a factual, well-researched response."},
                {"role": "user", "content": query}
            ]
        )
    else:
        # Use a different model for creative queries
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "Provide a creative, engaging response."},
                {"role": "user", "content": query}
            ]
        )

    return response.choices[0].message.content

# Run the function
result = process_user_query("Tell me about the history of artificial intelligence")

Ez egy nyomkövetést hoz létre a következőkkel:

• Fölérendeltség a következőhöz: process_user_query
• Két gyermektartomány az OpenAI-hívásokhoz

Következő lépések

Tekintse meg a következő oldalakat:

• Manuális nyomkövetés dekorátorokkal – Egyéni szakaszok hozzáadása az üzleti logika automatikusan követett LLM-hívásokkal együtt történő rögzítéséhez
• Az alkalmazás hibakeresése és megfigyelése – A Trace felhasználói felületén elemezheti az alkalmazás viselkedését és teljesítményét
• Alkalmazásminőség értékelése – A nyomkövetések használatával szisztematikusan értékelheti és javíthatja az alkalmazások minőségét

Referencia-útmutatók

Az útmutatóban említett fogalmakkal és funkciókkal kapcsolatos részletes dokumentációért tekintse meg a következőket:

• Minden integráció – Tallózás mind a 20 támogatott kódtárban és keretrendszerben
• Nyomkövetési fogalmak – Az MLflow Tracing alapjainak megismerése
• Nyomkövetési adatmodell – Tudnivalók a nyomkövetésekről, a spanokról és az attribútumokról