translate to english
This commit is contained in:
Davidson Gomes
@@ -1,6 +1,6 @@
|
||||
"""
|
||||
Script principal para executar todos os seeders em sequência.
|
||||
Verifica as dependências entre os seeders e executa na ordem correta.
|
||||
Main script to run all seeders in sequence.
|
||||
Checks dependencies between seeders and runs them in the correct order.
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -9,11 +9,11 @@ import logging
|
||||
import argparse
|
||||
from dotenv import load_dotenv
|
||||
|
||||
# Configurar logging
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Importar seeders
|
||||
# Import seeders
|
||||
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
from scripts.seeders.admin_seeder import create_admin_user
|
||||
from scripts.seeders.client_seeder import create_demo_client_and_user
|
||||
@@ -23,28 +23,28 @@ from scripts.seeders.tool_seeder import create_tools
|
||||
from scripts.seeders.contact_seeder import create_demo_contacts
|
||||
|
||||
def setup_environment():
|
||||
"""Configura o ambiente para os seeders"""
|
||||
"""Configure the environment for seeders"""
|
||||
load_dotenv()
|
||||
|
||||
# Verificar se as variáveis de ambiente essenciais estão definidas
|
||||
# Check if essential environment variables are defined
|
||||
required_vars = ["POSTGRES_CONNECTION_STRING"]
|
||||
missing_vars = [var for var in required_vars if not os.getenv(var)]
|
||||
|
||||
if missing_vars:
|
||||
logger.error(f"Variáveis de ambiente necessárias não definidas: {', '.join(missing_vars)}")
|
||||
logger.error(f"Required environment variables not defined: {', '.join(missing_vars)}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def run_seeders(seeders):
|
||||
"""
|
||||
Executa os seeders especificados
|
||||
Run the specified seeders
|
||||
|
||||
Args:
|
||||
seeders (list): Lista de seeders para executar
|
||||
seeders (list): List of seeders to run
|
||||
|
||||
Returns:
|
||||
bool: True se todos os seeders foram executados com sucesso, False caso contrário
|
||||
bool: True if all seeders were executed successfully, False otherwise
|
||||
"""
|
||||
all_seeders = {
|
||||
"admin": create_admin_user,
|
||||
@@ -55,58 +55,58 @@ def run_seeders(seeders):
|
||||
"contacts": create_demo_contacts
|
||||
}
|
||||
|
||||
# Define a ordem correta de execução (dependências)
|
||||
# Define the correct execution order (dependencies)
|
||||
seeder_order = ["admin", "client", "mcp_servers", "tools", "agents", "contacts"]
|
||||
|
||||
# Se nenhum seeder for especificado, executar todos
|
||||
# If no seeder is specified, run all
|
||||
if not seeders:
|
||||
seeders = seeder_order
|
||||
else:
|
||||
# Verificar se todos os seeders especificados existem
|
||||
# Check if all specified seeders exist
|
||||
invalid_seeders = [s for s in seeders if s not in all_seeders]
|
||||
if invalid_seeders:
|
||||
logger.error(f"Seeders inválidos: {', '.join(invalid_seeders)}")
|
||||
logger.info(f"Seeders disponíveis: {', '.join(all_seeders.keys())}")
|
||||
logger.error(f"Invalid seeders: {', '.join(invalid_seeders)}")
|
||||
logger.info(f"Available seeders: {', '.join(all_seeders.keys())}")
|
||||
return False
|
||||
|
||||
# Garantir que seeders sejam executados na ordem correta
|
||||
# Ensure seeders are executed in the correct order
|
||||
seeders = [s for s in seeder_order if s in seeders]
|
||||
|
||||
# Executar seeders
|
||||
# Run seeders
|
||||
success = True
|
||||
for seeder_name in seeders:
|
||||
logger.info(f"Executando seeder: {seeder_name}")
|
||||
logger.info(f"Running seeder: {seeder_name}")
|
||||
|
||||
try:
|
||||
seeder_func = all_seeders[seeder_name]
|
||||
if not seeder_func():
|
||||
logger.error(f"Falha ao executar seeder: {seeder_name}")
|
||||
logger.error(f"Failed to run seeder: {seeder_name}")
|
||||
success = False
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao executar seeder {seeder_name}: {str(e)}")
|
||||
logger.error(f"Error running seeder {seeder_name}: {str(e)}")
|
||||
success = False
|
||||
|
||||
return success
|
||||
|
||||
def main():
|
||||
"""Função principal"""
|
||||
parser = argparse.ArgumentParser(description='Executa seeders para popular o banco de dados')
|
||||
parser.add_argument('--seeders', nargs='+', help='Seeders para executar (admin, client, agents, mcp_servers, tools, contacts)')
|
||||
"""Main function"""
|
||||
parser = argparse.ArgumentParser(description='Run seeders to populate the database')
|
||||
parser.add_argument('--seeders', nargs='+', help='Seeders to run (admin, client, agents, mcp_servers, tools, contacts)')
|
||||
args = parser.parse_args()
|
||||
|
||||
# Configurar ambiente
|
||||
# Configure environment
|
||||
if not setup_environment():
|
||||
sys.exit(1)
|
||||
|
||||
# Executar seeders
|
||||
# Run seeders
|
||||
success = run_seeders(args.seeders)
|
||||
|
||||
# Saída
|
||||
# Output
|
||||
if success:
|
||||
logger.info("Todos os seeders foram executados com sucesso")
|
||||
logger.info("All seeders were executed successfully")
|
||||
sys.exit(0)
|
||||
else:
|
||||
logger.error("Houve erros ao executar os seeders")
|
||||
logger.error("There were errors running the seeders")
|
||||
sys.exit(1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
"""
|
||||
Script para criar um usuário administrador inicial:
|
||||
Script to create an initial admin user:
|
||||
- Email: admin@evoai.com
|
||||
- Senha: definida nas variáveis de ambiente ADMIN_INITIAL_PASSWORD
|
||||
- Password: defined in the ADMIN_INITIAL_PASSWORD environment variable
|
||||
- is_admin: True
|
||||
- is_active: True
|
||||
- email_verified: True
|
||||
@@ -21,27 +21,27 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def create_admin_user():
|
||||
"""Cria um usuário administrador inicial no sistema"""
|
||||
"""Create an initial admin user in the system"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Obter senha do administrador
|
||||
# Get admin password
|
||||
admin_password = os.getenv("ADMIN_INITIAL_PASSWORD")
|
||||
if not admin_password:
|
||||
logger.error("Variável de ambiente ADMIN_INITIAL_PASSWORD não definida")
|
||||
logger.error("Environment variable ADMIN_INITIAL_PASSWORD not defined")
|
||||
return False
|
||||
|
||||
# Configuração do email do admin
|
||||
# Admin email configuration
|
||||
admin_email = os.getenv("ADMIN_EMAIL", "admin@evoai.com")
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
@@ -49,10 +49,10 @@ def create_admin_user():
|
||||
# Verificar se o administrador já existe
|
||||
existing_admin = session.query(User).filter(User.email == admin_email).first()
|
||||
if existing_admin:
|
||||
logger.info(f"Administrador com email {admin_email} já existe")
|
||||
logger.info(f"Admin with email {admin_email} already exists")
|
||||
return True
|
||||
|
||||
# Criar administrador
|
||||
# Create admin
|
||||
admin_user = User(
|
||||
email=admin_email,
|
||||
password_hash=get_password_hash(admin_password),
|
||||
@@ -61,15 +61,15 @@ def create_admin_user():
|
||||
email_verified=True
|
||||
)
|
||||
|
||||
# Adicionar e comitar
|
||||
# Add and commit
|
||||
session.add(admin_user)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Administrador criado com sucesso: {admin_email}")
|
||||
logger.info(f"Admin created successfully: {admin_email}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar administrador: {str(e)}")
|
||||
logger.error(f"Error creating admin: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
"""
|
||||
Script para criar agentes de exemplo para o cliente demo:
|
||||
- Agente Atendimento: configurado para responder perguntas gerais
|
||||
- Agente Vendas: configurado para responder sobre produtos
|
||||
- Agente FAQ: configurado para responder perguntas frequentes
|
||||
Cada agente com instruções e configurações pré-definidas
|
||||
Script to create example agents for the demo client:
|
||||
- Agent Support: configured to answer general questions
|
||||
- Agent Sales: configured to answer about products
|
||||
- Agent FAQ: configured to answer frequently asked questions
|
||||
Each agent with pre-defined instructions and configurations
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -21,18 +21,18 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def create_demo_agents():
|
||||
"""Cria agentes de exemplo para o cliente demo"""
|
||||
"""Create example agents for the demo client"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
@@ -43,7 +43,7 @@ def create_demo_agents():
|
||||
demo_user = session.query(User).filter(User.email == demo_email).first()
|
||||
|
||||
if not demo_user or not demo_user.client_id:
|
||||
logger.error(f"Usuário demo não encontrado ou não associado a um cliente: {demo_email}")
|
||||
logger.error(f"Demo user not found or not associated with a client: {demo_email}")
|
||||
return False
|
||||
|
||||
client_id = demo_user.client_id
|
||||
@@ -51,79 +51,75 @@ def create_demo_agents():
|
||||
# Verificar se já existem agentes para este cliente
|
||||
existing_agents = session.query(Agent).filter(Agent.client_id == client_id).all()
|
||||
if existing_agents:
|
||||
logger.info(f"Já existem {len(existing_agents)} agentes para o cliente {client_id}")
|
||||
logger.info(f"There are already {len(existing_agents)} agents for the client {client_id}")
|
||||
return True
|
||||
|
||||
# Definições dos agentes de exemplo
|
||||
# Example agent definitions
|
||||
agents = [
|
||||
{
|
||||
"name": "Atendimento_Geral",
|
||||
"description": "Agente para atendimento geral e dúvidas básicas",
|
||||
"name": "Support_Agent",
|
||||
"description": "Agent for general support and basic questions",
|
||||
"type": "llm",
|
||||
"model": "gpt-3.5-turbo",
|
||||
"api_key": "${OPENAI_API_KEY}", # Será substituído pela variável de ambiente
|
||||
"model": "gpt-4.1-nano",
|
||||
"api_key": "your-api-key-here",
|
||||
"instruction": """
|
||||
Você é um assistente de atendimento ao cliente da empresa.
|
||||
Seja cordial, objetivo e eficiente. Responda às dúvidas dos clientes
|
||||
de forma clara e sucinta. Se não souber a resposta, informe que irá
|
||||
consultar um especialista e retornará em breve.
|
||||
You are a customer support agent.
|
||||
Be friendly, objective and efficient. Answer customer questions
|
||||
in a clear and concise manner. If you don't know the answer,
|
||||
inform that you will consult a specialist and return soon.
|
||||
""",
|
||||
"config": {
|
||||
"temperature": 0.7,
|
||||
"max_tokens": 500,
|
||||
"tools": []
|
||||
"tools": [],
|
||||
"mcp_servers": [],
|
||||
"custom_tools": [],
|
||||
"sub_agents": []
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "Vendas_Produtos",
|
||||
"description": "Agente especializado em vendas e informações sobre produtos",
|
||||
"name": "Sales_Products",
|
||||
"description": "Specialized agent in sales and information about products",
|
||||
"type": "llm",
|
||||
"model": "claude-3-sonnet-20240229",
|
||||
"api_key": "${ANTHROPIC_API_KEY}", # Será substituído pela variável de ambiente
|
||||
"model": "gpt-4.1-nano",
|
||||
"api_key": "your-api-key-here",
|
||||
"instruction": """
|
||||
Você é um especialista em vendas da empresa.
|
||||
Seu objetivo é fornecer informações detalhadas sobre produtos,
|
||||
comparar diferentes opções, destacar benefícios e vantagens competitivas.
|
||||
Use uma linguagem persuasiva mas honesta, e sempre busque entender
|
||||
as necessidades do cliente antes de recomendar um produto.
|
||||
You are a sales specialist.
|
||||
Your goal is to provide detailed information about products,
|
||||
compare different options, highlight benefits and competitive advantages.
|
||||
Use a persuasive but honest language, and always seek to understand
|
||||
the customer's needs before recommending a product.
|
||||
""",
|
||||
"config": {
|
||||
"temperature": 0.8,
|
||||
"max_tokens": 800,
|
||||
"tools": ["web_search"]
|
||||
"tools": [],
|
||||
"mcp_servers": [],
|
||||
"custom_tools": [],
|
||||
"sub_agents": []
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "FAQ_Bot",
|
||||
"description": "Agente para responder perguntas frequentes",
|
||||
"description": "Agent for answering frequently asked questions",
|
||||
"type": "llm",
|
||||
"model": "gemini-pro",
|
||||
"api_key": "${GOOGLE_API_KEY}", # Será substituído pela variável de ambiente
|
||||
"model": "gpt-4.1-nano",
|
||||
"api_key": "your-api-key-here",
|
||||
"instruction": """
|
||||
Você é um assistente especializado em responder perguntas frequentes.
|
||||
Suas respostas devem ser diretas, objetivas e baseadas nas informações
|
||||
da empresa. Utilize uma linguagem simples e acessível. Se a pergunta
|
||||
não estiver relacionada às FAQs disponíveis, direcione o cliente para
|
||||
o canal de atendimento adequado.
|
||||
You are a specialized agent for answering frequently asked questions.
|
||||
Your answers should be direct, objective and based on the information
|
||||
of the company. Use a simple and accessible language. If the question
|
||||
is not related to the available FAQs, redirect the client to the
|
||||
appropriate support channel.
|
||||
""",
|
||||
"config": {
|
||||
"temperature": 0.5,
|
||||
"max_tokens": 400,
|
||||
"tools": []
|
||||
"tools": [],
|
||||
"mcp_servers": [],
|
||||
"custom_tools": [],
|
||||
"sub_agents": []
|
||||
}
|
||||
}
|
||||
]
|
||||
|
||||
# Criar os agentes
|
||||
# Create the agents
|
||||
for agent_data in agents:
|
||||
# Substituir placeholders de API Keys por variáveis de ambiente quando disponíveis
|
||||
if "${OPENAI_API_KEY}" in agent_data["api_key"]:
|
||||
agent_data["api_key"] = os.getenv("OPENAI_API_KEY", "")
|
||||
elif "${ANTHROPIC_API_KEY}" in agent_data["api_key"]:
|
||||
agent_data["api_key"] = os.getenv("ANTHROPIC_API_KEY", "")
|
||||
elif "${GOOGLE_API_KEY}" in agent_data["api_key"]:
|
||||
agent_data["api_key"] = os.getenv("GOOGLE_API_KEY", "")
|
||||
|
||||
# Create the agent
|
||||
agent = Agent(
|
||||
client_id=client_id,
|
||||
name=agent_data["name"],
|
||||
@@ -136,19 +132,19 @@ def create_demo_agents():
|
||||
)
|
||||
|
||||
session.add(agent)
|
||||
logger.info(f"Agente '{agent_data['name']}' criado para o cliente {client_id}")
|
||||
logger.info(f"Agent '{agent_data['name']}' created for the client {client_id}")
|
||||
|
||||
session.commit()
|
||||
logger.info(f"Todos os agentes de exemplo foram criados com sucesso para o cliente {client_id}")
|
||||
logger.info(f"All example agents were created successfully for the client {client_id}")
|
||||
return True
|
||||
|
||||
except SQLAlchemyError as e:
|
||||
session.rollback()
|
||||
logger.error(f"Erro de banco de dados ao criar agentes de exemplo: {str(e)}")
|
||||
logger.error(f"Database error when creating example agents: {str(e)}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar agentes de exemplo: {str(e)}")
|
||||
logger.error(f"Error when creating example agents: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
"""
|
||||
Script para criar um cliente de exemplo:
|
||||
- Nome: Cliente Demo
|
||||
- Com usuário associado:
|
||||
- Email: demo@exemplo.com
|
||||
- Senha: demo123 (ou definida em variável de ambiente)
|
||||
Script to create a demo client:
|
||||
- Name: Demo Client
|
||||
- With associated user:
|
||||
- Email: demo@example.com
|
||||
- Password: demo123 (or defined in environment variable)
|
||||
- is_admin: False
|
||||
- is_active: True
|
||||
- email_verified: True
|
||||
@@ -24,42 +24,42 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def create_demo_client_and_user():
|
||||
"""Cria um cliente e usuário de demonstração no sistema"""
|
||||
"""Create a demo client and user in the system"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Obter senha do usuário demo (ou usar padrão)
|
||||
# Get demo user password (or use default)
|
||||
demo_password = os.getenv("DEMO_PASSWORD", "demo123")
|
||||
|
||||
# Configurações do cliente e usuário demo
|
||||
demo_client_name = os.getenv("DEMO_CLIENT_NAME", "Cliente Demo")
|
||||
demo_email = os.getenv("DEMO_EMAIL", "demo@exemplo.com")
|
||||
# Demo client and user settings
|
||||
demo_client_name = os.getenv("DEMO_CLIENT_NAME", "Demo Client")
|
||||
demo_email = os.getenv("DEMO_EMAIL", "demo@example.com")
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
|
||||
try:
|
||||
# Verificar se o usuário já existe
|
||||
# Check if the user already exists
|
||||
existing_user = session.query(User).filter(User.email == demo_email).first()
|
||||
if existing_user:
|
||||
logger.info(f"Usuário demo com email {demo_email} já existe")
|
||||
logger.info(f"Demo user with email {demo_email} already exists")
|
||||
return True
|
||||
|
||||
# Criar cliente demo
|
||||
# Create demo client
|
||||
demo_client = Client(name=demo_client_name)
|
||||
session.add(demo_client)
|
||||
session.flush() # Obter o ID do cliente
|
||||
session.flush() # Get the client ID
|
||||
|
||||
# Criar usuário demo associado ao cliente
|
||||
# Create demo user associated with the client
|
||||
demo_user = User(
|
||||
email=demo_email,
|
||||
password_hash=get_password_hash(demo_password),
|
||||
@@ -69,21 +69,21 @@ def create_demo_client_and_user():
|
||||
email_verified=True
|
||||
)
|
||||
|
||||
# Adicionar e comitar
|
||||
# Add and commit
|
||||
session.add(demo_user)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Cliente demo '{demo_client_name}' criado com sucesso")
|
||||
logger.info(f"Usuário demo criado com sucesso: {demo_email}")
|
||||
logger.info(f"Demo client '{demo_client_name}' created successfully")
|
||||
logger.info(f"Demo user created successfully: {demo_email}")
|
||||
return True
|
||||
|
||||
except SQLAlchemyError as e:
|
||||
session.rollback()
|
||||
logger.error(f"Erro de banco de dados ao criar cliente/usuário demo: {str(e)}")
|
||||
logger.error(f"Database error when creating demo client/user: {str(e)}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar cliente/usuário demo: {str(e)}")
|
||||
logger.error(f"Error when creating demo client/user: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
"""
|
||||
Script para criar contatos de exemplo para o cliente demo:
|
||||
- Contatos com histórico de conversas
|
||||
- Diferentes perfis de cliente
|
||||
- Dados fictícios para demonstração
|
||||
Script to create example contacts for the demo client:
|
||||
- Contacts with conversation history
|
||||
- Different client profiles
|
||||
- Fake data for demonstration
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -15,7 +15,7 @@ from sqlalchemy.exc import SQLAlchemyError
|
||||
from dotenv import load_dotenv
|
||||
from src.models.models import Contact, User, Client
|
||||
|
||||
# Configurar logging
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
|
||||
)
|
||||
@@ -23,46 +23,46 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def create_demo_contacts():
|
||||
"""Cria contatos de exemplo para o cliente demo"""
|
||||
"""Create example contacts for the demo client"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
|
||||
try:
|
||||
# Obter o cliente demo pelo email do usuário
|
||||
demo_email = os.getenv("DEMO_EMAIL", "demo@exemplo.com")
|
||||
# Get demo client by user email
|
||||
demo_email = os.getenv("DEMO_EMAIL", "demo@example.com")
|
||||
demo_user = session.query(User).filter(User.email == demo_email).first()
|
||||
|
||||
if not demo_user or not demo_user.client_id:
|
||||
logger.error(
|
||||
f"Usuário demo não encontrado ou não associado a um cliente: {demo_email}"
|
||||
f"Demo user not found or not associated with a client: {demo_email}"
|
||||
)
|
||||
return False
|
||||
|
||||
client_id = demo_user.client_id
|
||||
|
||||
# Verificar se já existem contatos para este cliente
|
||||
# Check if there are already contacts for this client
|
||||
existing_contacts = (
|
||||
session.query(Contact).filter(Contact.client_id == client_id).all()
|
||||
)
|
||||
if existing_contacts:
|
||||
logger.info(
|
||||
f"Já existem {len(existing_contacts)} contatos para o cliente {client_id}"
|
||||
f"There are already {len(existing_contacts)} contacts for the client {client_id}"
|
||||
)
|
||||
return True
|
||||
|
||||
# Definições dos contatos de exemplo
|
||||
# Example contact definitions
|
||||
contacts = [
|
||||
{
|
||||
"name": "Maria Silva",
|
||||
@@ -145,7 +145,7 @@ def create_demo_contacts():
|
||||
},
|
||||
]
|
||||
|
||||
# Criar os contatos
|
||||
# Create the contacts
|
||||
for contact_data in contacts:
|
||||
contact = Contact(
|
||||
client_id=client_id,
|
||||
@@ -156,24 +156,24 @@ def create_demo_contacts():
|
||||
|
||||
session.add(contact)
|
||||
logger.info(
|
||||
f"Contato '{contact_data['name']}' criado para o cliente {client_id}"
|
||||
f"Contact '{contact_data['name']}' created for the client {client_id}"
|
||||
)
|
||||
|
||||
session.commit()
|
||||
logger.info(
|
||||
f"Todos os contatos de exemplo foram criados com sucesso para o cliente {client_id}"
|
||||
f"All example contacts were created successfully for the client {client_id}"
|
||||
)
|
||||
return True
|
||||
|
||||
except SQLAlchemyError as e:
|
||||
session.rollback()
|
||||
logger.error(
|
||||
f"Erro de banco de dados ao criar contatos de exemplo: {str(e)}"
|
||||
f"Database error when creating example contacts: {str(e)}"
|
||||
)
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar contatos de exemplo: {str(e)}")
|
||||
logger.error(f"Error when creating example contacts: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
"""
|
||||
Script para criar servidores MCP padrão:
|
||||
- Servidor Anthropic Claude
|
||||
- Servidor OpenAI GPT
|
||||
- Servidor Google Gemini
|
||||
- Servidor Ollama (local)
|
||||
Cada um com configurações padrão para produção
|
||||
Script to create default MCP servers:
|
||||
- Anthropic Claude server
|
||||
- OpenAI GPT server
|
||||
- Google Gemini server
|
||||
- Ollama (local) server
|
||||
Each with default production configurations
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -16,7 +16,7 @@ from sqlalchemy.exc import SQLAlchemyError
|
||||
from dotenv import load_dotenv
|
||||
from src.models.models import MCPServer
|
||||
|
||||
# Configurar logging
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
|
||||
)
|
||||
@@ -24,32 +24,32 @@ logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def create_mcp_servers():
|
||||
"""Cria servidores MCP padrão no sistema"""
|
||||
"""Create default MCP servers in the system"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
|
||||
try:
|
||||
# Verificar se já existem servidores MCP
|
||||
# Check if there are already MCP servers
|
||||
existing_servers = session.query(MCPServer).all()
|
||||
if existing_servers:
|
||||
logger.info(
|
||||
f"Já existem {len(existing_servers)} servidores MCP cadastrados"
|
||||
f"There are already {len(existing_servers)} MCP servers registered"
|
||||
)
|
||||
return True
|
||||
|
||||
# Definições dos servidores MCP
|
||||
# MCP servers definitions
|
||||
mcp_servers = [
|
||||
{
|
||||
"name": "Sequential Thinking",
|
||||
@@ -62,7 +62,7 @@ def create_mcp_servers():
|
||||
],
|
||||
},
|
||||
"environments": {},
|
||||
"tools": ["sequential_thinking"],
|
||||
"tools": ["sequentialthinking"],
|
||||
"type": "community",
|
||||
"id": "4519dd69-9343-4792-af51-dc4d322fb0c9",
|
||||
"created_at": "2025-04-28T15:14:16.901236Z",
|
||||
@@ -180,7 +180,7 @@ def create_mcp_servers():
|
||||
},
|
||||
]
|
||||
|
||||
# Criar os servidores MCP
|
||||
# Create the MCP servers
|
||||
for server_data in mcp_servers:
|
||||
server = MCPServer(
|
||||
name=server_data["name"],
|
||||
@@ -192,19 +192,19 @@ def create_mcp_servers():
|
||||
)
|
||||
|
||||
session.add(server)
|
||||
logger.info(f"Servidor MCP '{server_data['name']}' criado com sucesso")
|
||||
logger.info(f"MCP server '{server_data['name']}' created successfully")
|
||||
|
||||
session.commit()
|
||||
logger.info("Todos os servidores MCP foram criados com sucesso")
|
||||
logger.info("All MCP servers were created successfully")
|
||||
return True
|
||||
|
||||
except SQLAlchemyError as e:
|
||||
session.rollback()
|
||||
logger.error(f"Erro de banco de dados ao criar servidores MCP: {str(e)}")
|
||||
logger.error(f"Database error when creating MCP servers: {str(e)}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar servidores MCP: {str(e)}")
|
||||
logger.error(f"Error when creating MCP servers: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
@@ -1,10 +1,7 @@
|
||||
"""
|
||||
Script para criar ferramentas padrão:
|
||||
- Pesquisa Web
|
||||
- Consulta a Documentos
|
||||
- Consulta a Base de Conhecimento
|
||||
- Integração WhatsApp/Telegram
|
||||
Cada uma com configurações básicas para demonstração
|
||||
Script to create default tools:
|
||||
-
|
||||
Each with basic configurations for demonstration
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -16,38 +13,38 @@ from sqlalchemy.exc import SQLAlchemyError
|
||||
from dotenv import load_dotenv
|
||||
from src.models.models import Tool
|
||||
|
||||
# Configurar logging
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def create_tools():
|
||||
"""Cria ferramentas padrão no sistema"""
|
||||
try:
|
||||
# Carregar variáveis de ambiente
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
|
||||
# Obter configurações do banco de dados
|
||||
# Get database settings
|
||||
db_url = os.getenv("POSTGRES_CONNECTION_STRING")
|
||||
if not db_url:
|
||||
logger.error("Variável de ambiente POSTGRES_CONNECTION_STRING não definida")
|
||||
logger.error("Environment variable POSTGRES_CONNECTION_STRING not defined")
|
||||
return False
|
||||
|
||||
# Conectar ao banco de dados
|
||||
# Connect to the database
|
||||
engine = create_engine(db_url)
|
||||
Session = sessionmaker(bind=engine)
|
||||
session = Session()
|
||||
|
||||
try:
|
||||
# Verificar se já existem ferramentas
|
||||
# Check if there are already tools
|
||||
existing_tools = session.query(Tool).all()
|
||||
if existing_tools:
|
||||
logger.info(f"Já existem {len(existing_tools)} ferramentas cadastradas")
|
||||
logger.info(f"There are already {len(existing_tools)} tools registered")
|
||||
return True
|
||||
|
||||
# Definições das ferramentas
|
||||
# Tools definitions
|
||||
tools = []
|
||||
|
||||
# Criar as ferramentas
|
||||
# Create the tools
|
||||
for tool_data in tools:
|
||||
|
||||
tool = Tool(
|
||||
@@ -58,19 +55,19 @@ def create_tools():
|
||||
)
|
||||
|
||||
session.add(tool)
|
||||
logger.info(f"Ferramenta '{tool_data['name']}' criada com sucesso")
|
||||
logger.info(f"Tool '{tool_data['name']}' created successfully")
|
||||
|
||||
session.commit()
|
||||
logger.info("Todas as ferramentas foram criadas com sucesso")
|
||||
logger.info("All tools were created successfully")
|
||||
return True
|
||||
|
||||
except SQLAlchemyError as e:
|
||||
session.rollback()
|
||||
logger.error(f"Erro de banco de dados ao criar ferramentas: {str(e)}")
|
||||
logger.error(f"Database error when creating tools: {str(e)}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Erro ao criar ferramentas: {str(e)}")
|
||||
logger.error(f"Error when creating tools: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
session.close()
|
||||
|
||||
Reference in New Issue
Block a user