Este é um projeto de um chatbot simples baseado em Python que utiliza o Azure LUIS (Language Understanding Intelligent Service) para identificar intenções e extrair entidades de mensagens fornecidas pelos usuários.
O chatbot é projetado para interpretar mensagens e identificar a intenção do usuário com base em um modelo treinado no Azure LUIS. Ele exibe a intenção identificada, bem como as entidades detectadas, e registra todas as interações em um arquivo de log.
- O chatbot recebe uma mensagem de texto do usuário.
- A mensagem é enviada para o serviço LUIS, que retorna:
- A intenção principal (intent).
- Entidades relevantes extraídas da mensagem.
- As informações são exibidas ao usuário e registradas em um arquivo de log.
- Conta no Azure com LUIS habilitado.
- Python 3.8 ou superior.
Este é um projeto de um chatbot simples baseado em Python que utiliza o Azure LUIS (Language Understanding Intelligent Service) para identificar intenções e extrair entidades de mensagens fornecidas pelos usuários.
O chatbot é projetado para interpretar mensagens e identificar a intenção do usuário com base em um modelo treinado no Azure LUIS. Ele exibe a intenção identificada, bem como as entidades detectadas, e registra todas as interações em um arquivo de log.
- O chatbot recebe uma mensagem de texto do usuário.
- A mensagem é enviada para o serviço LUIS, que retorna:
- A intenção principal (intent).
- Entidades relevantes extraídas da mensagem.
- As informações são exibidas ao usuário e registradas em um arquivo de log.
- Python: Linguagem de programação principal.
- Azure LUIS: Serviço de análise de linguagem natural.
- dotenv: Gerenciamento de variáveis de ambiente.
- Logging: Registro de eventos para depuração e monitoramento.
- Conta no Azure com LUIS habilitado.
- Python 3.8 ou superior.
- Instale as dependências:
- dentro da pasta .Chatbot/
pip install -r requirements.txt`- Configure as variáveis de ambiente no arquivo
.envna raiz do projeto:
APP_ID=seu-app-id-aqui
PREDICTION_KEY=sua-chave-de-api-aqui
ENDPOINT=seu-endpoint-aquiExecute o script principal:
python app.py- Digite uma mensagem para o chatbot. Por exemplo:
Você: Qual será o tempo amanhã?- O chatbot responderá com a intenção identificada e as entidades extraídas.
- Para encerrar, digite
sair.
- Configuração do Log:
- O sistema registra eventos no arquivo
logs/logChatbot.log. - Mensagens de erro, sucesso e interações são armazenadas.
- O sistema registra eventos no arquivo
- Integração com LUIS:
- O cliente LUIS é inicializado usando as configurações do
.env. - A função
obter_intencaoprocessa mensagens no LUIS e retorna as intenções e entidades.
- O cliente LUIS é inicializado usando as configurações do
- Chatbot Principal:
- Um loop processa mensagens do usuário e exibe os resultados.
O arquivo app.py é o código principal do chatbot. Ele integra o Azure LUIS com o Python, gerencia as entradas do usuário e registra as interações em um arquivo de log. Vamos explorar as principais partes do código:
`LOG_DIR = "logs"`
`LOG_FILE = os.path.join(LOG_DIR, "logChatbot.log")`
`os.makedirs(LOG_DIR, exist_ok=True)`
`logging.basicConfig(`
`level=logging.INFO,`
`format="%(asctime)s - %(levelname)s - %(message)s",`
`handlers=[`
`logging.FileHandler(LOG_FILE, encoding="utf-8"),`
`logging.StreamHandler() # Também exibe logs no console`
`]`
`)`
`logger = logging.getLogger(__name__)`- Objetivo: Configura o sistema de logging.
- Detalhes:
- O código cria um diretório
logspara armazenar os arquivos de log, caso ele não exista. - O arquivo de log
logChatbot.logé gerado dentro dessa pasta, e ele registra todas as mensagens (info, erro, etc.). - O logging também exibe mensagens no console enquanto o chatbot está sendo executado.
- O código cria um diretório
`if load_dotenv():`
`logger.info("Variáveis de ambiente carregadas com sucesso.")`
`else:`
`logger.error("Erro ao carregar as variáveis de ambiente. Verifique o arquivo .env.")`- Objetivo: Carregar variáveis de ambiente a partir do arquivo
.env. - Detalhes: O arquivo
.envcontém configurações sensíveis, como o APP_ID, PREDICTION_KEY e ENDPOINT do serviço LUIS. O código usa a bibliotecapython-dotenvpara carregar essas variáveis.
`APP_ID = os.getenv("APP_ID")`
`PREDICTION_KEY = os.getenv("PREDICTION_KEY")`
`ENDPOINT = os.getenv("ENDPOINT")`
`if not all([APP_ID, PREDICTION_KEY, ENDPOINT]):`
`logger.critical("Uma ou mais variáveis do .env não foram encontradas. Verifique o arquivo .env.")`
`exit(1)`- Objetivo: Garantir que todas as variáveis de ambiente estejam presentes.
- Detalhes: Se qualquer uma das variáveis estiver faltando, o sistema registra um erro crítico e encerra a execução.
`try:`
`client = LUISRuntimeClient(endpoint=ENDPOINT, credentials=CognitiveServicesCredentials(PREDICTION_KEY))`
`logger.info("Cliente LUIS inicializado com sucesso.")`
`except Exception as e:`
`logger.critical(f"Erro ao inicializar o cliente LUIS: {e}")`
`exit(1)`- Objetivo: Conectar ao serviço LUIS usando as credenciais fornecidas.
- Detalhes: O cliente LUIS é inicializado com o endpoint e a chave de API fornecidos. Se ocorrer algum erro na inicialização, o sistema registra o erro e termina a execução.
`def obter_intencao(mensagem):`
`try:`
`response = client.prediction.resolve(APP_ID, query=mensagem)`
`intent = response.top_scoring_intent.intent`
`entities = [(e.entity, e.type) for e in response.entities]`
`logger.info(f"Mensagem processada com sucesso. Intenção: {intent}, Entidades: {entities}")`
`return intent, entities`
`except Exception as e:`
`logger.error(f"Erro ao processar a mensagem no LUIS: {e}")`
`return "Erro", []`- Objetivo: Enviar uma mensagem para o LUIS e obter a intenção e as entidades.
- Detalhes:
- A mensagem do usuário é enviada para o modelo LUIS usando o método
resolve(). - A intenção principal e as entidades são extraídas da resposta.
- O sistema registra as intenções e entidades obtidas ou um erro, se ocorrer.
- A mensagem do usuário é enviada para o modelo LUIS usando o método
`if __name__ == "__main__":`
`logger.info("Chatbot iniciado. Digite sua mensagem ou 'sair' para encerrar.")`
`while True:`
`user_input = input("Você: ")`
`if user_input.lower() == "sair":`
`logger.info("Chatbot encerrado pelo usuário.")`
`break`
`intent, entities = obter_intencao(user_input)`
`print(f"Intenção: {intent}")`
`print(f"Entidades: {entities}")`- Objetivo: Controlar a interação com o usuário.
- Detalhes:
- O código entra em um loop onde o chatbot aguarda a entrada do usuário.
- O chatbot usa a função
obter_intencaopara processar a entrada e retorna a intenção e as entidades. - O usuário pode digitar "sair" para encerrar a interação.
O Language Understanding Intelligent Service (LUIS) é uma API de inteligência artificial da Microsoft que usa processamento de linguagem natural (NLP) para identificar intenções e extrair informações de mensagens em linguagem natural.
- Base de Respostas: O chatbot responde com base nas intenções detectadas pelo LUIS.
- Exemplo: Uma intenção chamada
Greetingpode indicar uma saudação, como "Olá!".
- Exemplo: Uma intenção chamada
- O sistema pode ser expandido para incluir respostas predefinidas em um arquivo JSON (opcional).
Todos os eventos, sucessos e erros são registrados no arquivo:
logs/logChatbot.log
*
**Exemplo de Log:**
2024-12-23 10:30:00 - INFO - Cliente LUIS inicializado com sucesso.
2024-12-23 10:31:00 - INFO - Mensagem processada com sucesso. Intenção: WeatherQuery, Entidades: [('tempo', 'consulta')]`
* Este projeto está licenciado sob a MIT License - veja o arquivo LICENSE para mais detalhes.