crewAI/docs/pt-BR/observability/mlflow.mdx

---
title: Integração com MLflow
description: Comece rapidamente a monitorar seus Agents com MLflow.
icon: bars-staggered
---

# Visão Geral do MLflow

[MLflow](https://mlflow.org/) é uma plataforma open-source que auxilia profissionais e equipes de machine learning a lidar com as complexidades do processo de aprendizagem de máquina.

Ela oferece um recurso de tracing que aprimora a observabilidade de LLMs em suas aplicações de IA Generativa, capturando informações detalhadas sobre a execução dos serviços de sua aplicação.
O tracing fornece uma forma de registrar os inputs, outputs e metadados associados a cada etapa intermediária de uma requisição, permitindo que você identifique facilmente a origem de bugs e comportamentos inesperados.

![Visão geral do uso de tracing MLflow com crewAI](/images/mlflow-tracing.gif)

### Funcionalidades

- **Painel de Tracing**: Monitore as atividades dos seus agentes crewAI com painéis detalhados que incluem entradas, saídas e metadados dos spans.
- **Tracing Automatizado**: Uma integração totalmente automatizada com crewAI, que pode ser habilitada executando `mlflow.crewai.autolog()`.
- **Instrumentação Manual de Tracing com pouco esforço**: Personalize a instrumentação dos traces usando as APIs de alto nível do MLflow, como decorators, wrappers de funções e context managers.
- **Compatibilidade com OpenTelemetry**: O MLflow Tracing suporta a exportação de traces para um OpenTelemetry Collector, que pode então ser usado para exportar traces para diversos backends como Jaeger, Zipkin e AWS X-Ray.
- **Empacote e Faça Deploy dos Agents**: Empacote e faça deploy de seus agents crewAI em um servidor de inferência com diversas opções de destino.
- **Hospede LLMs com Segurança**: Hospede múltiplos LLMs de vários provedores em um endpoint unificado através do gateway do MFflow.
- **Avaliação**: Avalie seus agents crewAI com uma ampla variedade de métricas utilizando a API conveniente `mlflow.evaluate()`.

## Instruções de Configuração

<Steps>
    <Step title="Instale o pacote MLflow">
      ```shell
      # A integração crewAI está disponível no mlflow>=2.19.0
      pip install mlflow
      ```
    </Step>
    <Step title="Inicie o servidor de tracking do MFflow">
      ```shell
      # Este processo é opcional, mas é recomendado utilizar o servidor de tracking do MLflow para melhor visualização e mais funcionalidades.
      mlflow server
      ```
    </Step>
    <Step title="Inicialize o MLflow em sua aplicação">
      Adicione as duas linhas a seguir ao código da sua aplicação:

      ```python
      import mlflow

      mlflow.crewai.autolog()

      # Opcional: Defina uma tracking URI e um nome de experimento caso utilize um servidor de tracking
      mlflow.set_tracking_uri("http://localhost:5000")
      mlflow.set_experiment("CrewAI")
      ```
      
      Exemplo de uso para tracing de Agents do CrewAI:

      ```python
      from crewai import Agent, Crew, Task
      from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
      from crewai_tools import SerperDevTool, WebsiteSearchTool

      from textwrap import dedent

      content = "Users name is John. He is 30 years old and lives in San Francisco."
      string_source = StringKnowledgeSource(
          content=content, metadata={"preference": "personal"}
      )

      search_tool = WebsiteSearchTool()


      class TripAgents:
          def city_selection_agent(self):
              return Agent(
                  role="City Selection Expert",
                  goal="Select the best city based on weather, season, and prices",
                  backstory="An expert in analyzing travel data to pick ideal destinations",
                  tools=[
                      search_tool,
                  ],
                  verbose=True,
              )

          def local_expert(self):
              return Agent(
                  role="Local Expert at this city",
                  goal="Provide the BEST insights about the selected city",
                  backstory="""A knowledgeable local guide with extensive information
              about the city, it's attractions and customs""",
                  tools=[search_tool],
                  verbose=True,
              )


      class TripTasks:
          def identify_task(self, agent, origin, cities, interests, range):
              return Task(
                  description=dedent(
                      f"""
                      Analyze and select the best city for the trip based
                      on specific criteria such as weather patterns, seasonal
                      events, and travel costs. This task involves comparing
                      multiple cities, considering factors like current weather
                      conditions, upcoming cultural or seasonal events, and
                      overall travel expenses.
                      Your final answer must be a detailed
                      report on the chosen city, and everything you found out
                      about it, including the actual flight costs, weather
                      forecast and attractions.

                      Traveling from: {origin}
                      City Options: {cities}
                      Trip Date: {range}
                      Traveler Interests: {interests}
                  """
                  ),
                  agent=agent,
                  expected_output="Detailed report on the chosen city including flight costs, weather forecast, and attractions",
              )

          def gather_task(self, agent, origin, interests, range):
              return Task(
                  description=dedent(
                      f"""
                      As a local expert on this city you must compile an
                      in-depth guide for someone traveling there and wanting
                      to have THE BEST trip ever!
                      Gather information about key attractions, local customs,
                      special events, and daily activity recommendations.
                      Find the best spots to go to, the kind of place only a
                      local would know.
                      This guide should provide a thorough overview of what
                      the city has to offer, including hidden gems, cultural
                      hotspots, must-visit landmarks, weather forecasts, and
                      high level costs.
                      The final answer must be a comprehensive city guide,
                      rich in cultural insights and practical tips,
                      tailored to enhance the travel experience.

                      Trip Date: {range}
                      Traveling from: {origin}
                      Traveler Interests: {interests}
                  """
                  ),
                  agent=agent,
                  expected_output="Comprehensive city guide including hidden gems, cultural hotspots, and practical travel tips",
              )


      class TripCrew:
          def __init__(self, origin, cities, date_range, interests):
              self.cities = cities
              self.origin = origin
              self.interests = interests
              self.date_range = date_range

          def run(self):
              agents = TripAgents()
              tasks = TripTasks()

              city_selector_agent = agents.city_selection_agent()
              local_expert_agent = agents.local_expert()

              identify_task = tasks.identify_task(
                  city_selector_agent,
                  self.origin,
                  self.cities,
                  self.interests,
                  self.date_range,
              )
              gather_task = tasks.gather_task(
                  local_expert_agent, self.origin, self.interests, self.date_range
              )

              crew = Crew(
                  agents=[city_selector_agent, local_expert_agent],
                  tasks=[identify_task, gather_task],
                  verbose=True,
                  memory=True,
                  knowledge={
                      "sources": [string_source],
                      "metadata": {"preference": "personal"},
                  },
              )

              result = crew.kickoff()
              return result


      trip_crew = TripCrew("California", "Tokyo", "Dec 12 - Dec 20", "sports")
      result = trip_crew.run()

      print(result)
      ```
      Consulte a [Documentação de Tracing do MLflow](https://mlflow.org/docs/latest/llms/tracing/index.html) para mais configurações e casos de uso.
    </Step>
    <Step title="Visualize as atividades dos Agents">
      Agora os traces dos seus agentes crewAI estão sendo capturados pelo MLflow.
      Vamos acessar o servidor de tracking do MLflow para visualizar os traces e obter insights dos seus Agents.

      Abra `127.0.0.1:5000` em seu navegador para acessar o servidor de tracking do MLflow.
      <Frame caption="Painel de Tracing do MLflow">
        <img src="/images/mlflow1.png" alt="Exemplo de tracing do MLflow com crewai" />
      </Frame>
    </Step>
</Steps>