agentops

Observabilidade e plataforma de devtool para agentes de IA

O AgentOps ajuda os desenvolvedores a construir, avaliar e monitorar agentes de IA. Do protótipo à produção.

Replay Analytics and Depurging	Gráficos de execução do agente passo a passo
? Gerenciamento de custos LLM	Rastrear gastos com provedores de modelos de fundação LLM
? Benchmarking do agente	Teste seus agentes contra mais de 1.000 evalas
? Conformidade e segurança	Detectar explorações comuns de injeção e exfiltração de dados
? Integrações da estrutura	Integrações nativas com Crewai, Autogen e Langchain

Iniciar rápido ⌨️

pip install agentops

Replays de sessão em 2 linhas de código

Inicialize o cliente do AgentOps e obtenha análises automaticamente em todas as suas chamadas LLM.

Obtenha uma chave de API

 import agentops

# Beginning of your program (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

...

# End of program
agentops . end_session ( 'Success' )

Todas as suas sessões podem ser visualizadas no painel do Agenteps

Depuração do agente

Replays de sessão

Resumo da análise

Experiência de desenvolvedor de primeira classe

Adicione a observabilidade poderosa aos seus agentes, ferramentas e funções com o mínimo de código possível: uma linha de cada vez.
Consulte a nossa documentação

 # Automatically associate all Events with the agent that originated them
from agentops import track_agent

@ track_agent ( name = 'SomeCustomName' )
class MyAgent :
  ...

 # Automatically create ToolEvents for tools that agents will use
from agentops import record_tool

@ record_tool ( 'SampleToolName' )
def sample_tool (...):
  ...

 # Automatically create ActionEvents for other functions.
from agentops import record_action

@ agentops . record_action ( 'sample function being record' )
def sample_function (...):
  ...

 # Manually record any other Events
from agentops import record , ActionEvent

record ( ActionEvent ( "received_user_input" ))

Integrações?

Crewai?

Construa agentes da tripulação com observabilidade com apenas 2 linhas de código. Basta definir um AGENTOPS_API_KEY em seu ambiente, e suas equipes receberão monitoramento automático no painel do AgentOps.

pip install ' crewai[agentops] '

• Exemplo de integração do agentes
• Documentação oficial do tripulação

AutoGen?

Com apenas duas linhas de código, adicione a observabilidade completa e o monitoramento aos agentes autogênicos. Defina um AGENTOPS_API_KEY em seu ambiente e ligue agentops.init()

• Exemplo de observabilidade automática
• Documentação Autogen - AgentOps

Langchain ??

O agentes funciona perfeitamente com aplicativos criados usando o Langchain. Para usar o manipulador, instale o Langchain como uma dependência opcional:

Instalação

pip install agentops[langchain]

Para usar o manipulador, importar e definir

 import os
from langchain . chat_models import ChatOpenAI
from langchain . agents import initialize_agent , AgentType
from agentops . partners . langchain_callback_handler import LangchainCallbackHandler

AGENTOPS_API_KEY = os . environ [ 'AGENTOPS_API_KEY' ]
handler = LangchainCallbackHandler ( api_key = AGENTOPS_API_KEY , tags = [ 'Langchain Example' ])

llm = ChatOpenAI ( openai_api_key = OPENAI_API_KEY ,
                 callbacks = [ handler ],
                 model = 'gpt-3.5-turbo' )

agent = initialize_agent ( tools ,
                         llm ,
                         agent = AgentType . CHAT_ZERO_SHOT_REACT_DESCRIPTION ,
                         verbose = True ,
                         callbacks = [ handler ], # You must pass in a callback handler to record your agent
                         handle_parsing_errors = True )

Confira o notebook Langchain Exemplos para obter mais detalhes, incluindo manipuladores de assíncronos.

Coere ⌨️

Suporte de primeira classe para coere (> = 5.4.0). Esta é uma integração viva, se você precisar de qualquer funcionalidade adicional, envie uma mensagem na discórdia!

• Exemplo de integração do agentes
• Documentação Oficial de Coere

Instalação

pip install cohere

 import cohere
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )
co = cohere . Client ()

chat = co . chat (
    message = "Is it pronounced ceaux-hear or co-hehray?"
)

print ( chat )

agentops . end_session ( 'Success' )

 import cohere
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

co = cohere . Client ()

stream = co . chat_stream (
    message = "Write me a haiku about the synergies between Cohere and AgentOps"
)

for event in stream :
    if event . event_type == "text-generation" :
        print ( event . text , end = '' )

agentops . end_session ( 'Success' )

Antrópico ﹨

Agentes de trilha construídos com o antropal Python SDK (> = 0,32,0).

• Guia de integração do Agenteps
• Documentação Antrópica Oficial

Instalação

pip install anthropic

 import anthropic
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

client = anthropic . Anthropic (
    # This is the default and can be omitted
    api_key = os . environ . get ( "ANTHROPIC_API_KEY" ),
)

message = client . messages . create (
        max_tokens = 1024 ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me a cool fact about AgentOps" ,
            }
        ],
        model = "claude-3-opus-20240229" ,
    )
print ( message . content )

agentops . end_session ( 'Success' )

Transmissão

 import anthropic
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

client = anthropic . Anthropic (
    # This is the default and can be omitted
    api_key = os . environ . get ( "ANTHROPIC_API_KEY" ),
)

stream = client . messages . create (
    max_tokens = 1024 ,
    model = "claude-3-opus-20240229" ,
    messages = [
        {
            "role" : "user" ,
            "content" : "Tell me something cool about streaming agents" ,
        }
    ],
    stream = True ,
)

response = ""
for event in stream :
    if event . type == "content_block_delta" :
        response += event . delta . text
    elif event . type == "message_stop" :
        print ( " n " )
        print ( response )
        print ( " n " )

Assíncrono

 import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic (
    # This is the default and can be omitted
    api_key = os . environ . get ( "ANTHROPIC_API_KEY" ),
)


async def main () -> None :
    message = await client . messages . create (
        max_tokens = 1024 ,
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me something interesting about async agents" ,
            }
        ],
        model = "claude-3-opus-20240229" ,
    )
    print ( message . content )


await main ()

Mistral 〽️

Agentes de trilha construídos com o antropal Python SDK (> = 0,32,0).

• Exemplo de integração do agentes
• Documentação Mistral Oficial

Instalação

pip install mistralai

Sincronização

 from mistralai import Mistral
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

client = Mistral (
    # This is the default and can be omitted
    api_key = os . environ . get ( "MISTRAL_API_KEY" ),
)

message = client . chat . complete (
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me a cool fact about AgentOps" ,
            }
        ],
        model = "open-mistral-nemo" ,
    )
print ( message . choices [ 0 ]. message . content )

agentops . end_session ( 'Success' )

Transmissão

 from mistralai import Mistral
import agentops

# Beginning of program's code (i.e. main.py, __init__.py)
agentops . init ( < INSERT YOUR API KEY HERE > )

client = Mistral (
    # This is the default and can be omitted
    api_key = os . environ . get ( "MISTRAL_API_KEY" ),
)

message = client . chat . stream (
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me something cool about streaming agents" ,
            }
        ],
        model = "open-mistral-nemo" ,
    )

response = ""
for event in message :
    if event . data . choices [ 0 ]. finish_reason == "stop" :
        print ( " n " )
        print ( response )
        print ( " n " )
    else :
        response += event . text

agentops . end_session ( 'Success' )

Assíncrono

 import asyncio
from mistralai import Mistral

client = Mistral (
    # This is the default and can be omitted
    api_key = os . environ . get ( "MISTRAL_API_KEY" ),
)


async def main () -> None :
    message = await client . chat . complete_async (
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me something interesting about async agents" ,
            }
        ],
        model = "open-mistral-nemo" ,
    )
    print ( message . choices [ 0 ]. message . content )


await main ()

Streaming assíncrono

 import asyncio
from mistralai import Mistral

client = Mistral (
    # This is the default and can be omitted
    api_key = os . environ . get ( "MISTRAL_API_KEY" ),
)


async def main () -> None :
    message = await client . chat . stream_async (
        messages = [
            {
                "role" : "user" ,
                "content" : "Tell me something interesting about async streaming agents" ,
            }
        ],
        model = "open-mistral-nemo" ,
    )

    response = ""
    async for event in message :
        if event . data . choices [ 0 ]. finish_reason == "stop" :
            print ( " n " )
            print ( response )
            print ( " n " )
        else :
            response += event . text


await main ()

Litellm?

O AgentOps fornece suporte para Litellm (> = 1.3.1), permitindo que você ligue para 100+ LLMS usando o mesmo formato de entrada/saída.

• Exemplo de integração do agentes
• Documentação Oficial de Litellm

Instalação

pip install litellm

 # Do not use LiteLLM like this
# from litellm import completion
# ...
# response = completion(model="claude-3", messages=messages)

# Use LiteLLM like this
import litellm
...
response = litellm . completion ( model = "claude-3" , messages = messages )
# or
response = await litellm . acompletion ( model = "claude-3" , messages = messages )

Llamaindex?

O Agenteps trabalha perfeitamente com aplicativos criados usando o Llamaindex, uma estrutura para criar aplicativos de IA generativos com contexto de contexto com o LLMS.

Instalação

pip install llama-index-instrumentation-agentops

Para usar o manipulador, importar e definir

 from llama_index . core import set_global_handler

# NOTE: Feel free to set your AgentOps environment variables (e.g., 'AGENTOPS_API_KEY')
# as outlined in the AgentOps documentation, or pass the equivalent keyword arguments
# anticipated by AgentOps' AOClient as **eval_params in set_global_handler.

set_global_handler ( "agentops" )

Confira os documentos do Llandeindex para obter mais detalhes.

Depuração da viagem no tempo?

Experimente!

Arena de agente?

(em breve!)

Roteiro de avaliações?

Plataforma	Painel	Evals
✅ Python SDK	✅ Métricas de várias sessões e sessões cruzadas	✅ Métricas de avaliação personalizadas
? API do construtor de avaliação	✅ Rastreamento de tags de evento personalizado	Agente scorecards
✅ JavaScript/TypeScript SDK	✅ Replays de sessão	Avaliação Playground + liderança

Roteiro de depuração?

Teste de desempenho	Ambientes	Teste de LLM	Teste de raciocínio e execução
✅ Análise de latência de eventos	Testes ambientais não estacionários	Detecção de função não determinística de LLM	? Loops infinitos e detecção de pensamento recursivo
✅ Preços de execução do fluxo de trabalho do agente	Ambientes multimodais	? Sinalizadores de transbordamento de limite de token	Detecção de raciocínio defeituoso
? Validadores de sucesso (externo)	Contêineres de execução	Sinalizadores de excesso de limite de contexto	Validadores de código generativos
Controladores de agentes/testes de habilidade	✅ Honeypot e detecção de injeção imediata (Prompmor)	Rastreamento de Bill API	Análise do ponto de interrupção do erro
Teste de restrição de contexto de informação	Bloco de estrada anti-agente (ou seja, captchas)	Verificações de integração de CI/CD
Teste de regressão	Visualização da estrutura multi-agente

Por que agentes? ?

Sem as ferramentas certas, os agentes da IA ​​são lentos, caros e não confiáveis. Nossa missão é levar seu agente do protótipo à produção. Eis por que o Agenteps se destaca:

• Observabilidade abrangente : rastreie o desempenho de seus agentes de IA, as interações do usuário e o uso da API.
• Monitoramento em tempo real : obtenha informações instantâneas com replays de sessão, métricas e ferramentas de monitoramento ao vivo.
• Controle de custos : monitore e gerencie seus gastos em chamadas de LLM e API.
• Detecção de falhas : identifique e responda rapidamente às falhas do agente e problemas de interação com vários agentes.
• Estatísticas de uso da ferramenta : entenda como seus agentes utilizam ferramentas externas com análises detalhadas.
• Métricas em toda a sessão : obtenha uma visão holística das sessões de seus agentes com estatísticas abrangentes.

O AgentOps foi projetado para facilitar a observabilidade do agente, testes e monitoramento.

História da estrela

Confira nosso crescimento na comunidade:

Projetos populares usando agenteps

Repositório	Estrelas
geekan / metagpt	42787
Run-llama / llama_index	34446
Crewaiinc / Crewai	18287
Camelo-AI / Camel	5166
Superagente-AI / SuperAgente	5050
Iyaja / llama-fs	4713
BasedHardware / OMI	2723
Mervinpraon / Praonai	2007
AGENTOPS-AI / JAIQU	272
Strnad / Crewai-Studio	134
Alejandro-AO / Exa-Crewai	55
Tonykipkemboi / youtube_yapper_trapper	47
Sethcoast / Cover-Letter-Builder	27
Bhancockio / ChatGpt4o-análise	19
BreakString / Agentic_story_book_workflow	14
Multi-On / Multion-Python	13

Gerado usando Github-Dependents-Info, por Nicolas Vuillamy