ia-tracker-qca 0.1.0__py3-none-any.whl

ia_cost_tracker/__init__.py

@@ -0,0 +1,27 @@
+"""
+IA Cost Tracker - Biblioteca para rastreamento de custos de APIs de IA.
+
+Esta biblioteca permite rastrear e auditar custos de chamadas a APIs de IA
+como Maritaca e Anthropic, salvando informações detalhadas em banco de dados.
+
+Para Maritaca: sincroniza preços via API
+Para Anthropic: usa preços mantidos no banco de dados
+"""
+
+__version__ = "0.1.0"
+
+from .tracker import IATracker
+from .exceptions import (
+    IATrackerError,
+    DatabaseError,
+    ProviderError,
+    ModelNotFoundError,
+)
+
+__all__ = [
+    "IATracker",
+    "IATrackerError",
+    "DatabaseError",
+    "ProviderError",
+    "ModelNotFoundError",
+]

ia_cost_tracker/database.py

@@ -0,0 +1,290 @@
+"""Gerenciador de conexões e operações com banco de dados."""
+
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from typing import List, Optional, Dict, Any
+from contextlib import contextmanager
+from decimal import Decimal
+import logging
+
+from .models import ModeloIA, UsoToken
+from .exceptions import DatabaseError, ModelNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseManager:
+    """
+    Gerenciador de conexões e operações com PostgreSQL.
+    
+    Esta classe gerencia todas as interações com o banco de dados,
+    incluindo operações CRUD para modelos e registros de uso.
+    """
+    
+    def __init__(self, connection_string: str):
+        """
+        Inicializa o gerenciador de banco de dados.
+        
+        Args:
+            connection_string: String de conexão PostgreSQL
+                              (ex: "postgresql://user:pass@localhost/dbname")
+        
+        Raises:
+            DatabaseError: Se houver erro na conexão com o banco
+        """
+        self.connection_string = connection_string
+        self._test_connection()
+    
+    def _test_connection(self) -> None:
+        """Testa a conexão com o banco de dados."""
+        try:
+            with self._get_connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("SELECT 1")
+        except Exception as e:
+            raise DatabaseError(f"Erro ao conectar ao banco de dados: {str(e)}")
+    
+    @contextmanager
+    def _get_connection(self):
+        """
+        Context manager para conexões com o banco.
+        
+        Yields:
+            psycopg2.connection: Conexão com o banco de dados
+        """
+        conn = None
+        try:
+            conn = psycopg2.connect(self.connection_string)
+            yield conn
+            conn.commit()
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Erro na operação do banco: {str(e)}")
+        finally:
+            if conn:
+                conn.close()
+    
+    @staticmethod
+    def _convert_decimal_to_float(row_dict: Dict) -> Dict:
+        """
+        Converte valores Decimal para float no dicionário.
+        
+        Args:
+            row_dict: Dicionário com dados do banco
+        
+        Returns:
+            Dicionário com Decimals convertidos para float
+        """
+        converted = {}
+        for key, value in row_dict.items():
+            if isinstance(value, Decimal):
+                converted[key] = float(value)
+            else:
+                converted[key] = value
+        return converted
+    
+    def buscar_modelo(self, provedor: str, nome_modelo: str) -> Optional[ModeloIA]:
+        """
+        Busca um modelo específico no banco de dados.
+        
+        Args:
+            provedor: Nome do provedor (ex: 'maritaca', 'anthropic')
+            nome_modelo: Nome do modelo
+        
+        Returns:
+            ModeloIA se encontrado, None caso contrário
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT id_modelo, provedor, nome_modelo, custo_input_por_1k,
+                   custo_output_por_1k, ativo, criado_em
+            FROM dim_modelo_ia
+            WHERE provedor = %s AND nome_modelo = %s AND ativo = true
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, (provedor, nome_modelo))
+                row = cur.fetchone()
+                
+                if row:
+                    row_dict = self._convert_decimal_to_float(dict(row))
+                    return ModeloIA(**row_dict)
+                return None
+    
+    def listar_modelos(self, provedor: Optional[str] = None, 
+                      apenas_ativos: bool = True) -> List[ModeloIA]:
+        """
+        Lista modelos do banco de dados.
+        
+        Args:
+            provedor: Filtrar por provedor específico (opcional)
+            apenas_ativos: Se True, retorna apenas modelos ativos
+        
+        Returns:
+            Lista de ModeloIA
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT id_modelo, provedor, nome_modelo, custo_input_por_1k,
+                   custo_output_por_1k, ativo, criado_em
+            FROM dim_modelo_ia
+            WHERE 1=1
+        """
+        params = []
+        
+        if provedor:
+            query += " AND provedor = %s"
+            params.append(provedor)
+        
+        if apenas_ativos:
+            query += " AND ativo = true"
+        
+        query += " ORDER BY provedor, nome_modelo"
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, params)
+                rows = cur.fetchall()
+                modelos = []
+                for row in rows:
+                    row_dict = self._convert_decimal_to_float(dict(row))
+                    modelos.append(ModeloIA(**row_dict))
+                return modelos
+    
+    def inserir_ou_atualizar_modelo(self, modelo: ModeloIA) -> int:
+        """
+        Insere um novo modelo ou atualiza se já existir.
+        
+        Args:
+            modelo: Objeto ModeloIA a ser inserido/atualizado
+        
+        Returns:
+            ID do modelo inserido/atualizado
+        
+        Raises:
+            DatabaseError: Se houver erro na operação
+        """
+        query = """
+            INSERT INTO dim_modelo_ia 
+                (provedor, nome_modelo, custo_input_por_1k, custo_output_por_1k, ativo)
+            VALUES (%s, %s, %s, %s, %s)
+            ON CONFLICT (provedor, nome_modelo) 
+            DO UPDATE SET
+                custo_input_por_1k = EXCLUDED.custo_input_por_1k,
+                custo_output_por_1k = EXCLUDED.custo_output_por_1k,
+                ativo = EXCLUDED.ativo
+            RETURNING id_modelo
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(query, (
+                    modelo.provedor,
+                    modelo.nome_modelo,
+                    modelo.custo_input_por_1k,
+                    modelo.custo_output_por_1k,
+                    modelo.ativo
+                ))
+                id_modelo = cur.fetchone()[0]
+                logger.info(f"Modelo {modelo.provedor}/{modelo.nome_modelo} "
+                          f"inserido/atualizado com ID {id_modelo}")
+                return id_modelo
+    
+    def registrar_uso(self, uso: UsoToken) -> int:
+        """
+        Registra um uso de tokens no banco de dados.
+        
+        Args:
+            uso: Objeto UsoToken com os dados do uso
+        
+        Returns:
+            ID do registro de uso criado
+        
+        Raises:
+            DatabaseError: Se houver erro na inserção
+        """
+        query = """
+            INSERT INTO fato_uso_tokens (
+                id_modelo, tokens_input, tokens_output,
+                custo_input, custo_output, tag_funcionalidade,
+                aplicacao, usuario, tempo_resposta_ms,
+                erro, mensagem_erro, timestamp_uso
+            ) VALUES (
+                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+            ) RETURNING id_uso
+        """
+        
+        with self._get_connection() as conn:
+            with conn.cursor() as cur:
+                cur.execute(query, (
+                    uso.id_modelo,
+                    uso.tokens_input,
+                    uso.tokens_output,
+                    uso.custo_input,
+                    uso.custo_output,
+                    uso.tag_funcionalidade,
+                    uso.aplicacao,
+                    uso.usuario,
+                    uso.tempo_resposta_ms,
+                    uso.erro,
+                    uso.mensagem_erro,
+                    uso.timestamp_uso
+                ))
+                id_uso = cur.fetchone()[0]
+                logger.info(f"Uso registrado com ID {id_uso} - "
+                          f"Custo total: R$ {uso.custo_total:.6f}")
+                return id_uso
+    
+    def buscar_custos_por_aplicacao(self, aplicacao: str, 
+                                    data_inicio: Optional[Any] = None,
+                                    data_fim: Optional[Any] = None) -> Dict[str, Any]:
+        """
+        Busca estatísticas de custo para uma aplicação específica.
+        
+        Args:
+            aplicacao: Nome da aplicação
+            data_inicio: Data inicial do período (opcional)
+            data_fim: Data final do período (opcional)
+        
+        Returns:
+            Dicionário com estatísticas de uso e custo
+        
+        Raises:
+            DatabaseError: Se houver erro na consulta
+        """
+        query = """
+            SELECT 
+                COUNT(*) as total_chamadas,
+                SUM(tokens_input) as total_tokens_input,
+                SUM(tokens_output) as total_tokens_output,
+                SUM(tokens_total) as total_tokens,
+                SUM(custo_total) as custo_total,
+                AVG(custo_total) as custo_medio,
+                AVG(tempo_resposta_ms) as tempo_medio_resposta_ms,
+                SUM(CASE WHEN erro = true THEN 1 ELSE 0 END) as total_erros
+            FROM fato_uso_tokens
+            WHERE aplicacao = %s
+        """
+        params = [aplicacao]
+        
+        if data_inicio:
+            query += " AND timestamp_uso >= %s"
+            params.append(data_inicio)
+        
+        if data_fim:
+            query += " AND timestamp_uso <= %s"
+            params.append(data_fim)
+        
+        with self._get_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(query, params)
+                resultado = cur.fetchone()
+                if resultado:
+                    return self._convert_decimal_to_float(dict(resultado))
+                return {}

ia_cost_tracker/exceptions.py

@@ -0,0 +1,26 @@
+"""Exceções personalizadas para o IA Cost Tracker."""
+
+
+class IATrackerError(Exception):
+    """Exceção base para erros do IA Cost Tracker."""
+    pass
+
+
+class DatabaseError(IATrackerError):
+    """Exceção para erros relacionados ao banco de dados."""
+    pass
+
+
+class ProviderError(IATrackerError):
+    """Exceção para erros relacionados aos provedores de IA."""
+    pass
+
+
+class ModelNotFoundError(IATrackerError):
+    """Exceção quando um modelo não é encontrado no banco de dados."""
+    pass
+
+
+class ConfigurationError(IATrackerError):
+    """Exceção para erros de configuração."""
+    pass

ia_cost_tracker/models.py

@@ -0,0 +1,72 @@
+"""Modelos de dados para o IA Cost Tracker."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class ModeloIA:
+    """
+    Representa um modelo de IA com seus custos.
+    
+    Attributes:
+        id_modelo: ID do modelo no banco de dados
+        provedor: Nome do provedor (maritaca, anthropic, etc)
+        nome_modelo: Nome do modelo
+        custo_input_por_1k: Custo por 1000 tokens de entrada
+        custo_output_por_1k: Custo por 1000 tokens de saída
+        ativo: Se o modelo está ativo
+        criado_em: Data de criação do registro
+    """
+    provedor: str
+    nome_modelo: str
+    custo_input_por_1k: float
+    custo_output_por_1k: float
+    id_modelo: Optional[int] = None
+    ativo: bool = True
+    criado_em: Optional[datetime] = None
+
+
+@dataclass
+class UsoToken:
+    """
+    Representa um registro de uso de tokens.
+    
+    Attributes:
+        id_modelo: ID do modelo utilizado
+        tokens_input: Quantidade de tokens de entrada
+        tokens_output: Quantidade de tokens de saída
+        custo_input: Custo total da entrada
+        custo_output: Custo total da saída
+        tag_funcionalidade: Tag para identificar a funcionalidade
+        aplicacao: Nome da aplicação que fez a chamada
+        usuario: Usuário que realizou a chamada
+        tempo_resposta_ms: Tempo de resposta em milissegundos
+        erro: Se houve erro na chamada
+        mensagem_erro: Mensagem de erro, se houver
+        id_uso: ID do registro (gerado pelo banco)
+        timestamp_uso: Timestamp do uso
+        tokens_total: Total de tokens (calculado)
+        custo_total: Custo total (calculado)
+    """
+    id_modelo: int
+    tokens_input: int
+    tokens_output: int
+    custo_input: float
+    custo_output: float
+    tag_funcionalidade: Optional[str] = None
+    aplicacao: Optional[str] = None
+    usuario: Optional[str] = None
+    tempo_resposta_ms: Optional[int] = None
+    erro: bool = False
+    mensagem_erro: Optional[str] = None
+    id_uso: Optional[int] = None
+    timestamp_uso: Optional[datetime] = field(default_factory=datetime.now)
+    tokens_total: Optional[int] = field(init=False)
+    custo_total: Optional[float] = field(init=False)
+    
+    def __post_init__(self):
+        """Calcula campos derivados."""
+        self.tokens_total = self.tokens_input + self.tokens_output
+        self.custo_total = self.custo_input + self.custo_output

ia_cost_tracker/providers/__init__.py

@@ -0,0 +1,11 @@
+"""Módulo de provedores de IA."""
+
+from .base import BaseProvider
+from .maritaca import MaritacaProvider
+from .anthropic import AnthropicProvider
+
+__all__ = [
+    "BaseProvider",
+    "MaritacaProvider",
+    "AnthropicProvider",
+]

ia_cost_tracker/providers/anthropic.py

@@ -0,0 +1,81 @@
+"""Provider para Anthropic (Claude)."""
+
+from typing import List, Dict, Optional
+import logging
+
+from .base import BaseProvider
+from ..models import ModeloIA
+from ..exceptions import ProviderError
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicProvider(BaseProvider):
+    """
+    Provider para integração com Anthropic (Claude).
+    
+    Busca modelos e preços diretamente do banco de dados,
+    já que a Anthropic não possui API pública para consulta de preços.
+    
+    Os preços devem ser mantidos atualizados manualmente no banco.
+    """
+    
+    def __init__(self, db_manager=None):
+        """
+        Inicializa o provider da Anthropic.
+        
+        Args:
+            db_manager: Instância do DatabaseManager para buscar preços do banco
+        """
+        super().__init__("anthropic")
+        self.db_manager = db_manager
+    
+    def buscar_modelos_disponiveis(self) -> List[ModeloIA]:
+        """
+        Busca modelos disponíveis da Anthropic do banco de dados.
+        
+        Returns:
+            Lista de ModeloIA com modelos e preços
+        
+        Raises:
+            ProviderError: Se o DatabaseManager não estiver configurado
+        """
+        if not self.db_manager:
+            raise ProviderError(
+                "DatabaseManager não configurado para AnthropicProvider. "
+                "Os modelos da Anthropic são gerenciados diretamente no banco de dados."
+            )
+        
+        modelos = self.db_manager.listar_modelos(
+            provedor=self.provider_name,
+            apenas_ativos=True
+        )
+        
+        logger.info(f"Buscados {len(modelos)} modelos da Anthropic do banco de dados")
+        return modelos
+    
+    def calcular_custo(self, nome_modelo: str, tokens_input: int, 
+                      tokens_output: int, custo_input_1k: float,
+                      custo_output_1k: float) -> Dict[str, float]:
+        """
+        Calcula o custo de uma chamada à Anthropic.
+        
+        Args:
+            nome_modelo: Nome do modelo utilizado
+            tokens_input: Quantidade de tokens de entrada
+            tokens_output: Quantidade de tokens de saída
+            custo_input_1k: Custo por 1000 tokens de entrada
+            custo_output_1k: Custo por 1000 tokens de saída
+        
+        Returns:
+            Dicionário com custos calculados
+        """
+        custo_input = (tokens_input / 1000) * custo_input_1k
+        custo_output = (tokens_output / 1000) * custo_output_1k
+        custo_total = custo_input + custo_output
+        
+        return {
+            'custo_input': round(custo_input, 6),
+            'custo_output': round(custo_output, 6),
+            'custo_total': round(custo_total, 6)
+        }

ia_cost_tracker/providers/base.py

@@ -0,0 +1,55 @@
+"""Classe base para provedores de IA."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List
+from ..models import ModeloIA
+
+
+class BaseProvider(ABC):
+    """
+    Classe base abstrata para provedores de IA.
+    
+    Cada provedor (Maritaca, Anthropic, etc) deve herdar desta classe
+    e implementar os métodos abstratos.
+    """
+    
+    def __init__(self, provider_name: str):
+        """
+        Inicializa o provedor base.
+        
+        Args:
+            provider_name: Nome do provedor
+        """
+        self.provider_name = provider_name
+    
+    @abstractmethod
+    def buscar_modelos_disponiveis(self) -> List[ModeloIA]:
+        """
+        Busca a lista de modelos disponíveis do provedor.
+        
+        Returns:
+            Lista de objetos ModeloIA com os modelos e preços
+        
+        Raises:
+            ProviderError: Se houver erro ao buscar os modelos
+        """
+        pass
+    
+    @abstractmethod
+    def calcular_custo(self, nome_modelo: str, tokens_input: int, 
+                      tokens_output: int, custo_input_1k: float,
+                      custo_output_1k: float) -> Dict[str, float]:
+        """
+        Calcula o custo de uma chamada.
+        
+        Args:
+            nome_modelo: Nome do modelo utilizado
+            tokens_input: Quantidade de tokens de entrada
+            tokens_output: Quantidade de tokens de saída
+            custo_input_1k: Custo por 1000 tokens de entrada
+            custo_output_1k: Custo por 1000 tokens de saída
+        
+        Returns:
+            Dicionário com 'custo_input', 'custo_output' e 'custo_total'
+        """
+        pass

ia_cost_tracker/providers/maritaca.py

@@ -0,0 +1,142 @@
+"""Provider para Maritaca AI."""
+
+import requests
+from typing import List, Dict
+import logging
+
+from .base import BaseProvider
+from ..models import ModeloIA
+from ..exceptions import ProviderError
+
+logger = logging.getLogger(__name__)
+
+
+class MaritacaProvider(BaseProvider):
+    """
+    Provider para integração com Maritaca AI.
+    
+    Busca modelos e preços através da API da Maritaca.
+    """
+    
+    def __init__(self, api_key: str, base_url: str = "https://chat.maritaca.ai"):
+        """
+        Inicializa o provider da Maritaca.
+        
+        Args:
+            api_key: Chave de API da Maritaca
+            base_url: URL base da API (padrão: https://chat.maritaca.ai)
+        """
+        super().__init__("maritaca")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+    
+    def buscar_modelos_disponiveis(self) -> List[ModeloIA]:
+        """
+        Busca modelos disponíveis da API da Maritaca.
+        
+        A API retorna um dicionário com:
+        - models: dict com modelos ativos (chave = nome do modelo)
+        - deprecated_models: dict com modelos deprecados
+        
+        Cada modelo contém:
+        - input_price: preço por token de entrada
+        - output_price: preço por token de saída
+        - offpeak_input_price: preço reduzido em horário de pico
+        - offpeak_output_price: preço reduzido em horário de pico
+        - batch_input_price: preço para lote
+        - batch_output_price: preço para lote
+        
+        Returns:
+            Lista de ModeloIA com modelos e preços
+        
+        Raises:
+            ProviderError: Se houver erro ao buscar os modelos
+        """
+        url = f"{self.base_url}/api/chat/models"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        try:
+            response = requests.get(url, headers=headers, timeout=30)
+            response.raise_for_status()
+            
+            data = response.json()
+            modelos = []
+            
+            # Processar modelos ativos
+            if 'models' in data and isinstance(data['models'], dict):
+                for nome_modelo, detalhes in data['models'].items():
+                    # Preços vêm por token, convertemos para por 1k tokens
+                    input_price_per_token = detalhes.get('input_price', 0)
+                    output_price_per_token = detalhes.get('output_price', 0)
+                    
+                    # Converter para preço por 1k tokens
+                    custo_input_por_1k = input_price_per_token * 1000
+                    custo_output_por_1k = output_price_per_token * 1000
+                    
+                    modelo = ModeloIA(
+                        provedor=self.provider_name,
+                        nome_modelo=nome_modelo,
+                        custo_input_por_1k=custo_input_por_1k,
+                        custo_output_por_1k=custo_output_por_1k,
+                        ativo=True
+                    )
+                    modelos.append(modelo)
+                    
+                    logger.debug(
+                        f"Modelo {nome_modelo}: "
+                        f"input={custo_input_por_1k:.6f}, "
+                        f"output={custo_output_por_1k:.6f} por 1k tokens"
+                    )
+            
+            # Opcional: Processar modelos deprecados (marcados como inativos)
+            if 'deprecated_models' in data and isinstance(data['deprecated_models'], dict):
+                for nome_modelo, detalhes in data['deprecated_models'].items():
+                    # Modelos deprecados podem não ter preços, usar 0
+                    modelo = ModeloIA(
+                        provedor=self.provider_name,
+                        nome_modelo=nome_modelo,
+                        custo_input_por_1k=0.0,
+                        custo_output_por_1k=0.0,
+                        ativo=False
+                    )
+                    modelos.append(modelo)
+                    
+                    logger.debug(f"Modelo deprecado: {nome_modelo}")
+            
+            logger.info(f"Buscados {len(modelos)} modelos da Maritaca "
+                       f"({sum(1 for m in modelos if m.ativo)} ativos)")
+            return modelos
+            
+        except requests.RequestException as e:
+            raise ProviderError(f"Erro ao buscar modelos da Maritaca: {str(e)}")
+        except (KeyError, ValueError, TypeError) as e:
+            raise ProviderError(f"Erro ao processar resposta da Maritaca: {str(e)}")
+    
+    def calcular_custo(self, nome_modelo: str, tokens_input: int, 
+                      tokens_output: int, custo_input_1k: float,
+                      custo_output_1k: float) -> Dict[str, float]:
+        """
+        Calcula o custo de uma chamada à Maritaca.
+        
+        Args:
+            nome_modelo: Nome do modelo utilizado
+            tokens_input: Quantidade de tokens de entrada
+            tokens_output: Quantidade de tokens de saída
+            custo_input_1k: Custo por 1000 tokens de entrada
+            custo_output_1k: Custo por 1000 tokens de saída
+        
+        Returns:
+            Dicionário com custos calculados
+        """
+        custo_input = (tokens_input / 1000) * custo_input_1k
+        custo_output = (tokens_output / 1000) * custo_output_1k
+        custo_total = custo_input + custo_output
+        
+        return {
+            'custo_input': round(custo_input, 6),
+            'custo_output': round(custo_output, 6),
+            'custo_total': round(custo_total, 6)
+        }

ia_cost_tracker/tracker.py

@@ -0,0 +1,357 @@
+"""Classe principal do IA Cost Tracker."""
+
+import logging
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+import time
+
+from .database import DatabaseManager
+from .models import ModeloIA, UsoToken
+from .providers import MaritacaProvider, AnthropicProvider
+from .exceptions import ModelNotFoundError, ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+
+class IATracker:
+    """
+    Classe principal para rastreamento de custos de IA.
+    
+    Esta classe gerencia o rastreamento de uso e custos de chamadas
+    a APIs de IA, incluindo sincronização de preços e registro de uso.
+    
+    Example:
+        >>> tracker = IATracker(
+        ...     db_connection_string="postgresql://user:pass@localhost/db",
+        ...     maritaca_api_key="sua-chave"
+        ... )
+        >>> 
+        >>> # Sincronizar preços da Maritaca
+        >>> tracker.sincronizar_precos_maritaca()
+        >>> 
+        >>> # Registrar uso (Anthropic busca preços do banco automaticamente)
+        >>> tracker.registrar_chamada(
+        ...     provedor="anthropic",
+        ...     modelo="claude-3-5-sonnet-20241022",
+        ...     tokens_input=100,
+        ...     tokens_output=50,
+        ...     aplicacao="meu-app",
+        ...     tag_funcionalidade="chat"
+        ... )
+    """
+    
+    def __init__(self,
+                 db_connection_string: str,
+                 maritaca_api_key: Optional[str] = None,
+                 maritaca_base_url: str = "https://chat.maritaca.ai"):
+        """
+        Inicializa o IA Cost Tracker.
+        
+        Args:
+            db_connection_string: String de conexão PostgreSQL
+            maritaca_api_key: Chave de API da Maritaca (opcional)
+            maritaca_base_url: URL base da API Maritaca
+        
+        Raises:
+            ConfigurationError: Se a configuração for inválida
+        """
+        self.db = DatabaseManager(db_connection_string)
+        
+        # Maritaca Provider (precisa de API key)
+        self.maritaca = None
+        if maritaca_api_key:
+            self.maritaca = MaritacaProvider(maritaca_api_key, maritaca_base_url)
+        
+        # Anthropic Provider (usa o banco de dados)
+        self.anthropic = AnthropicProvider(db_manager=self.db)
+        
+        logger.info("IATracker inicializado com sucesso")
+    
+    def sincronizar_precos_maritaca(self) -> int:
+        """
+        Sincroniza os preços dos modelos da Maritaca.
+        
+        Busca os modelos e preços da API da Maritaca e
+        atualiza o banco de dados.
+        
+        Returns:
+            Número de modelos sincronizados
+        
+        Raises:
+            ConfigurationError: Se a Maritaca não estiver configurada
+            ProviderError: Se houver erro ao buscar os modelos
+        """
+        if not self.maritaca:
+            raise ConfigurationError(
+                "Maritaca não configurada. Forneça maritaca_api_key na inicialização."
+            )
+        
+        modelos = self.maritaca.buscar_modelos_disponiveis()
+        
+        count = 0
+        for modelo in modelos:
+            self.db.inserir_ou_atualizar_modelo(modelo)
+            count += 1
+        
+        logger.info(f"{count} modelos da Maritaca sincronizados")
+        return count
+    
+    def listar_modelos_anthropic(self) -> List[ModeloIA]:
+        """
+        Lista os modelos da Anthropic disponíveis no banco de dados.
+        
+        Returns:
+            Lista de ModeloIA da Anthropic
+        
+        Note:
+            Os preços da Anthropic devem ser mantidos manualmente no banco,
+            pois não há API pública para consulta.
+        """
+        modelos = self.anthropic.buscar_modelos_disponiveis()
+        logger.info(f"{len(modelos)} modelos da Anthropic encontrados no banco")
+        return modelos
+    
+    def registrar_chamada(self,
+                         provedor: str,
+                         modelo: str,
+                         tokens_input: int,
+                         tokens_output: int,
+                         aplicacao: Optional[str] = None,
+                         tag_funcionalidade: Optional[str] = None,
+                         usuario: Optional[str] = None,
+                         tempo_resposta_ms: Optional[int] = None,
+                         erro: bool = False,
+                         mensagem_erro: Optional[str] = None) -> int:
+        """
+        Registra uma chamada de IA no banco de dados.
+        
+        Args:
+            provedor: Nome do provedor (maritaca, anthropic)
+            modelo: Nome do modelo utilizado
+            tokens_input: Quantidade de tokens de entrada
+            tokens_output: Quantidade de tokens de saída
+            aplicacao: Nome da aplicação que fez a chamada
+            tag_funcionalidade: Tag para identificar a funcionalidade
+            usuario: Usuário que realizou a chamada
+            tempo_resposta_ms: Tempo de resposta em milissegundos
+            erro: Se houve erro na chamada
+            mensagem_erro: Mensagem de erro, se houver
+        
+        Returns:
+            ID do registro de uso criado
+        
+        Raises:
+            ModelNotFoundError: Se o modelo não for encontrado no banco
+        
+        Example:
+            >>> tracker.registrar_chamada(
+            ...     provedor="anthropic",
+            ...     modelo="claude-3-5-sonnet-20241022",
+            ...     tokens_input=150,
+            ...     tokens_output=75,
+            ...     aplicacao="chat-app",
+            ...     tag_funcionalidade="suporte"
+            ... )
+        """
+        # Buscar modelo no banco
+        modelo_db = self.db.buscar_modelo(provedor, modelo)
+        
+        if not modelo_db:
+            raise ModelNotFoundError(
+                f"Modelo {provedor}/{modelo} não encontrado no banco de dados. "
+                f"Para Maritaca, execute sincronizar_precos_maritaca(). "
+                f"Para Anthropic, adicione o modelo manualmente no banco."
+            )
+        
+        # Calcular custos
+        provider = self._get_provider(provedor)
+        custos = provider.calcular_custo(
+            modelo,
+            tokens_input,
+            tokens_output,
+            modelo_db.custo_input_por_1k,
+            modelo_db.custo_output_por_1k
+        )
+        
+        # Criar registro de uso
+        uso = UsoToken(
+            id_modelo=modelo_db.id_modelo,
+            tokens_input=tokens_input,
+            tokens_output=tokens_output,
+            custo_input=custos['custo_input'],
+            custo_output=custos['custo_output'],
+            aplicacao=aplicacao,
+            tag_funcionalidade=tag_funcionalidade,
+            usuario=usuario,
+            tempo_resposta_ms=tempo_resposta_ms,
+            erro=erro,
+            mensagem_erro=mensagem_erro
+        )
+        
+        return self.db.registrar_uso(uso)
+    
+    def _get_provider(self, provedor: str):
+        """
+        Retorna o provider correspondente ao nome.
+        
+        Args:
+            provedor: Nome do provedor
+        
+        Returns:
+            Instância do provider
+        
+        Raises:
+            ConfigurationError: Se o provedor não for suportado
+        """
+        provedor_lower = provedor.lower()
+        
+        if provedor_lower == "maritaca":
+            if not self.maritaca:
+                raise ConfigurationError(
+                    "Maritaca não configurada. Forneça maritaca_api_key na inicialização."
+                )
+            return self.maritaca
+        elif provedor_lower == "anthropic":
+            return self.anthropic
+        else:
+            raise ConfigurationError(
+                f"Provedor desconhecido: {provedor}. "
+                f"Provedores suportados: maritaca, anthropic"
+            )
+    
+    def track_call(self, 
+                   provedor: str,
+                   modelo: str,
+                   aplicacao: Optional[str] = None,
+                   tag_funcionalidade: Optional[str] = None,
+                   usuario: Optional[str] = None):
+        """
+        Decorator para rastrear automaticamente chamadas de IA.
+        
+        Args:
+            provedor: Nome do provedor (maritaca, anthropic)
+            modelo: Nome do modelo utilizado
+            aplicacao: Nome da aplicação
+            tag_funcionalidade: Tag para identificar a funcionalidade
+            usuario: Usuário que realizou a chamada
+        
+        Returns:
+            Decorator function
+        
+        Example:
+            >>> @tracker.track_call(
+            ...     provedor="anthropic",
+            ...     modelo="claude-3-5-sonnet-20241022",
+            ...     aplicacao="chat-app"
+            ... )
+            ... def processar_mensagem(mensagem):
+            ...     response = client.messages.create(
+            ...         model="claude-3-5-sonnet-20241022",
+            ...         messages=[{"role": "user", "content": mensagem}]
+            ...     )
+            ...     return response
+        """
+        def decorator(func):
+            def wrapper(*args, **kwargs):
+                start_time = time.time()
+                erro = False
+                mensagem_erro = None
+                result = None
+                
+                try:
+                    result = func(*args, **kwargs)
+                    return result
+                except Exception as e:
+                    erro = True
+                    mensagem_erro = str(e)
+                    raise
+                finally:
+                    tempo_resposta_ms = int((time.time() - start_time) * 1000)
+                    
+                    # Extrair tokens da resposta
+                    tokens_input = 0
+                    tokens_output = 0
+                    
+                    # Tentar diferentes formatos de resposta
+                    if result:
+                        # Formato Anthropic
+                        if hasattr(result, 'usage'):
+                            tokens_input = getattr(result.usage, 'input_tokens', 0)
+                            tokens_output = getattr(result.usage, 'output_tokens', 0)
+                        # Formato OpenAI-like (Maritaca pode usar)
+                        elif isinstance(result, dict) and 'usage' in result:
+                            usage = result['usage']
+                            tokens_input = usage.get('prompt_tokens', 0)
+                            tokens_output = usage.get('completion_tokens', 0)
+                    
+                    try:
+                        if tokens_input > 0 or tokens_output > 0:
+                            self.registrar_chamada(
+                                provedor=provedor,
+                                modelo=modelo,
+                                tokens_input=tokens_input,
+                                tokens_output=tokens_output,
+                                aplicacao=aplicacao,
+                                tag_funcionalidade=tag_funcionalidade,
+                                usuario=usuario,
+                                tempo_resposta_ms=tempo_resposta_ms,
+                                erro=erro,
+                                mensagem_erro=mensagem_erro
+                            )
+                        else:
+                            logger.warning(
+                                "Não foi possível extrair tokens da resposta. "
+                                "Registro não criado."
+                            )
+                    except Exception as e:
+                        logger.error(f"Erro ao registrar chamada: {str(e)}")
+            
+            return wrapper
+        return decorator
+    
+    def obter_estatisticas_aplicacao(self,
+                                     aplicacao: str,
+                                     data_inicio: Optional[datetime] = None,
+                                     data_fim: Optional[datetime] = None) -> Dict[str, Any]:
+        """
+        Obtém estatísticas de uso para uma aplicação.
+        
+        Args:
+            aplicacao: Nome da aplicação
+            data_inicio: Data inicial do período
+            data_fim: Data final do período
+        
+        Returns:
+            Dicionário com estatísticas de uso e custo
+        
+        Example:
+            >>> from datetime import datetime, timedelta
+            >>> data_inicio = datetime.now() - timedelta(days=7)
+            >>> stats = tracker.obter_estatisticas_aplicacao(
+            ...     "meu-app",
+            ...     data_inicio=data_inicio
+            ... )
+            >>> print(f"Custo total: R$ {stats['custo_total']:.2f}")
+        """
+        return self.db.buscar_custos_por_aplicacao(aplicacao, data_inicio, data_fim)
+    
+    def listar_modelos(self, provedor: Optional[str] = None) -> List[ModeloIA]:
+        """
+        Lista modelos disponíveis no banco de dados.
+        
+        Args:
+            provedor: Filtrar por provedor específico (opcional)
+        
+        Returns:
+            Lista de ModeloIA
+        
+        Example:
+            >>> # Listar todos os modelos
+            >>> todos = tracker.listar_modelos()
+            >>> 
+            >>> # Listar apenas Anthropic
+            >>> anthropic = tracker.listar_modelos(provedor="anthropic")
+            >>> for m in anthropic:
+            ...     print(f"{m.nome_modelo}: R$ {m.custo_input_por_1k}/1k")
+        """
+        return self.db.listar_modelos(provedor=provedor)

ia_tracker_qca-0.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: ia_tracker_qca
+Version: 0.1.0
+Summary: Biblioteca para rastreamento e auditoria de custos de APIs de IA
+Author-email: Sua Equipe <contato@suaempresa.com>
+License: MIT
+Project-URL: Homepage, https://github.com/suaempresa/ia-cost-tracker
+Project-URL: Documentation, https://github.com/suaempresa/ia-cost-tracker#readme
+Project-URL: Repository, https://github.com/suaempresa/ia-cost-tracker
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: python-dotenv>=0.19.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# IA Cost Tracker
+
+[![PyPI version](https://badge.fury.io/py/ia-cost-tracker.svg)](https://badge.fury.io/py/ia-cost-tracker)
+[![Python Versions](https://img.shields.io/pypi/pyversions/ia-cost-tracker.svg)](https://pypi.org/project/ia-cost-tracker/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Downloads](https://pepy.tech/badge/ia-cost-tracker)](https://pepy.tech/project/ia-cost-tracker)
+
+Rastreie custos de APIs de IA (Maritaca, Anthropic) automaticamente.
+
+Biblioteca Python para rastreamento e auditoria de custos de APIs de IA (Maritaca, Anthropic).
+
+## Instalação
+
+```bash
+pip install pip install ia_tracker_qca
+
+```
+
+Uso básico (não recomendado pois demora mais por causa que busca os valores atualizados na hora!):
+
+```python
+from ia_cost_tracker import IATracker
+
+# Inicializar
+tracker = IATracker(
+    db_connection_string="postgresql://user:pass@localhost/db",
+    maritaca_api_key="sua-chave",
+    anthropic_api_key="sua-chave"
+)
+
+# Sincronizar preços dos modelos
+tracker.sincronizar_precos_maritaca() #essa chamada a api demora uns 10segs as vezes.
+tracker.sincronizar_precos_anthropic()
+
+# Registrar uma chamada
+tracker.registrar_chamada(
+    provedor="maritaca",
+    modelo="sabia-2-medium",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="usuario@email.com"
+)
+
+# Obter estatísticas
+stats = tracker.obter_estatisticas_aplicacao("meu-app")
+print(f"Custo total: R$ {stats['custo_total']}")
+print(f"Total de chamadas: {stats['total_chamadas']}")
+
+```
+
+
+Exemplo de uso em uma aplicação em produção:
+```python
+from ia_cost_tracker import IATracker
+
+tracker = IATracker(db_connection_string=os.getenv("DB_CONNECTION_STRING"))
+
+# Após chamar a IA
+tracker.registrar_chamada(
+    provedor="maritaca",  # ou "anthropic"
+    modelo="sabia-4",
+    tokens_input=150,
+    tokens_output=75,
+    aplicacao="meu-app",
+    tag_funcionalidade="chat",
+    usuario="user@email.com"  # opcional
+)
+```
+
+Desenvolvimento:
+
+```bash
+# Clonar repositório
+git clone https://github.com/suaempresa/ia-cost-tracker
+cd ia-cost-tracker
+
+# Instalar em modo desenvolvimento
+pip install -e ".[dev]"
+
+# Rodar testes
+pytest
+
+# Formatar código
+black src/
+isort src/
+```
+
+Consultar Custos:
+
+```python
+from datetime import datetime, timedelta
+
+# Últimos 7 dias
+data_inicio = datetime.now() - timedelta(days=7)
+stats = tracker.obter_estatisticas_aplicacao(
+    aplicacao="meu-app",
+    data_inicio=data_inicio
+)
+
+# Listar modelos disponíveis
+modelos = tracker.listar_modelos(provedor="maritaca")
+for modelo in modelos:
+    print(f"{modelo.nome_modelo}: "
+          f"R$ {modelo.custo_input_por_1k}/1k input, "
+          f"R$ {modelo.custo_output_por_1k}/1k output")
+
+```

ia_tracker_qca-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+ia_cost_tracker/__init__.py,sha256=zxycoNe5hNjk7UVI0wIisyzsVatDIJhYofZY1oIODW8,646
+ia_cost_tracker/database.py,sha256=11JEiBjAEDzrlJzZXz7SKCDyvCK54GJPzjQ4-5bHWiM,10282
+ia_cost_tracker/exceptions.py,sha256=vm032KW8XPVQCCASzsRU0GPK7qYgc40ds15KO0QLs3E,636
+ia_cost_tracker/models.py,sha256=pGc3bbgUx6VerlfG9-yG_bgyM8NLs0Eef-5OOglZSeM,2500
+ia_cost_tracker/tracker.py,sha256=1fNqav0dlSBZsqLV5WZIF3bjL7IzcgYufMwHXumFTL0,13717
+ia_cost_tracker/providers/__init__.py,sha256=XRL0u59YpikkjmgDfAd-e6fX-_3rsJHyqmJBPeo7q5U,240
+ia_cost_tracker/providers/anthropic.py,sha256=S8utx3aR0o1Hmt8G5QI7zcNwJJCob-oEIqUeyKVB-BQ,2795
+ia_cost_tracker/providers/base.py,sha256=V-8s8qUHVxJSOo3difQO30Q3IGN6e1yt5sxUCsPOMQM,1687
+ia_cost_tracker/providers/maritaca.py,sha256=JnRwt0naBRnPH0FHdNVkZ9ZfwpSJwHpmFYBv6rl3P88,5735
+ia_tracker_qca-0.1.0.dist-info/licenses/LICENCE,sha256=Xpa1tEk-XW4tkTokBTU-bngiw8cbfGtqBoNVBjKnFAo,1096
+ia_tracker_qca-0.1.0.dist-info/METADATA,sha256=F-CIvLcAvWNRSHZ7ok40DsLFB64OzcfGl1Md9suffIU,4198
+ia_tracker_qca-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ia_tracker_qca-0.1.0.dist-info/top_level.txt,sha256=OUDlog_CDGtGd2Xc1EQuCg-hiYQfGcsf91c5Ob4NelQ,16
+ia_tracker_qca-0.1.0.dist-info/RECORD,,

ia_tracker_qca-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ia_tracker_qca-0.1.0.dist-info/licenses/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elison Felipe Santos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ia_tracker_qca-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ia_cost_tracker