# fernandofps20/ia-project architecture

> Architecture diagram of the GitHub repository fernandofps20/ia-project, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2025-04-03). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/fernandofps20/ia-project
- Repository: https://github.com/fernandofps20/ia-project

## Overview

A seguir estão as orientações detalhadas para criar um diagrama de arquitetura que represente com clareza o sistema do projeto "IA Project - Conversor de Linguagem Natural para SQL", conforme indicado pelo README e a estrutura de arquivos.

##### Identificação do Projeto e Propósito
- Trata-se de uma API que utiliza inteligência artificial (via Ollama) para converter linguagem natural em consultas SQL.
- O projeto integra um backend Node.js (usando Express) a um banco de dados MySQL e também conta com uma camada de modelagem SQL configurada em “sqlModel”.
- Embora a API seja o foco, a presença de arquivos estáticos (HTML, CSS, JS na pasta public) sugere uma interface (possivelmente para testes ou apresentação) que deve ser considerada no diagrama se relevante ao fluxo.

##### Principais Componentes e Padrões Arquitetônicos
a. Componentes do Sistema:
- Frontend (Interface Web): Arquivos presentes na pasta “public” (HTML, CSS e JavaScript) que podem servir como interface para requisições ou testes.
- Backend / API: Localizado em “src”, com:
- app.js e server.js: Configura e inicia o servidor Express.
- Rotas: Definidas em “src/routes/promptRoutes.js”, mapeando os endpoints (como o POST /api/data).
- Controladores: Exemplo em “src/controllers/promptController.js” e “src/controllers/abortController.js”, que processam as requisições.
- Configuração do Banco de Dados: “src/config/db.js”, que estabelece a conexão MySQL.
- Utilitários: “src/utils/helper.js”, contendo funções auxiliares.
- Serviço Externo – Ollama: A API integra o modelo de linguagem (SQL model) do Ollama para interpretar os prompts, com configurações e scripts contidos na pasta “sqlModel”.
- Banco de Dados MySQL: Onde as queries geradas são executadas. As variáveis de ambiente (DB_HOST, DB_USER, etc.) definem a conexão.

b. Relacionamentos e Interações:
- O Frontend (se utilizado) envia uma requisição (por exemplo, via formulário ou chamada AJAX) para a API.
- A rota POST /api/data recebe o prompt em texto, que é tratado pelo promptController.
- O controlador invoca o serviço do Ollama, utilizando o modelo configurado na pasta “sqlModel”, para converter o texto em uma consulta SQL.
- A consulta SQL é, então, executada por meio da conexão configurada no “src/config/db.js” para interagir com o banco de dados MySQL.
- As respostas e resultados são retornadas para o cliente (frontend ou outro consumidor da API).

c. Padrões Arquitetônicos e Design:
- A estrutura adota um padrão MVC simplificado: as rotas (interface de entrada) direcionam para controladores (lógica), que por sua vez se comunicam com a camada de configuração e banco de dados.
- O uso de containers (Docker e Docker Compose) implica que o ambiente de execução é isolado; a imagem construída a partir do Dockerfile e a orquestração via docker-compose refletem isso.
- A modularização (divisão clara entre config, controllers, routes, utils) facilita a manutenção e expansão do sistema.

##### Tecnologias, Frameworks e Integrações
- Node.js e Express para o backend.
- MySQL como sistema de gerenciamento de banco de dados.
- Ollama para a integração com inteligência artificial e conversão de linguagem natural em SQL.
- Docker e Docker Compose para containerização e facilitação da implantação.

##### Instruções para Criar o Diagrama
a. Estruture o diagrama separando os componentes principais:
- Um bloco representando o Frontend (se houver interface web) – use ícones ou formas para indicar HTML, CSS e JavaScript.
- Um bloco para o Backend/API, destacando:
- Servidor Express (app.js, server.js).
- Rotas (promptRoutes.js) e Controladores (promptController.js, abortController.js) como subcomponentes.
- Uma indicação para os arquivos de configuração e utilitários.
- Um bloco para o Banco de Dados MySQL.
- Um bloco para o Serviço Externo – Ollama (incluindo a pasta sqlModel).
- Um bloco que representa o ambiente de containerização gerenciado via Docker/Docker Compose.
b. Demonstre as relações:
- Utilize setas direcionais para mostrar o fluxo de dados: Por exemplo, do Frontend para o Backend, do Backend para o Serviço Externo (Ollama), e o Backend para o Banco de Dados.
- Destaque os pontos de entrada (como o endpoint POST /api/data) e as saídas de dados (resultados da consulta SQL).
c. Destaque a comunicação:
- Use cores ou diferentes formas para distinguir entre componentes de interface, lógica de aplicação, serviços externos e persistência de dados.
- Adicione rótulos claros, como “API Endpoint (/api/data)”, “Conversor AI (Ollama)”, “Banco de Dados MySQL”, “Docker Container”, etc.
d. Adicione detalhes sobre as dependências e o fluxo de requisições:
- Mostre que o fluxograma se inicia com o recebimento do prompt, passa pelo controlador, invoca o serviço do Ollama, e então interage com o banco de dados.

##### Diretrizes Específicas para Este Projeto
- Certifique-se de incluir todas as áreas relevantes: Módulo de roteamento, camada de controle, serviço de integração com IA e conexão com o banco de dados.
- Mantenha o diagrama modular e detalhado, separando claramente cada camada – isso facilita a compreensão e futuras melhorias.
- Utilize setas para indicar a direção de fluxo dos dados e dependências entre módulos, e, se possível, inclua também a identificação dos arquivos/configurações que originaram cada componente (por exemplo, “src/config/db.js” para o banco de dados).
- Considere adicionar uma nota sobre a integração do Docker, indicando que tanto o servidor quanto os dados podem estar isolados em containers, o que ajuda a visualizar a infraestrutura de implantação.

Em resumo, para desenhar o diagrama ideal, comece identificando todos os componentes críticos (Frontend, Backend/API, Serviço Ollama, Banco de Dados e Ambiente Docker), mapeie de forma clara as relações e fluxos entre eles, e utilize convenções visuais (rótulos, setas, cores/ícones) para tornar o diagrama intuitivo e abrangente. Essa abordagem garantirá que todos os aspectos essenciais da arquitetura – desde as rotas até as integrações de IA – estejam representados de forma precisa e útil para a análise e manutenção do sistema.

## Diagram (Mermaid)

```mermaid
flowchart TD
    %% Frontend Subgraph
    subgraph "Frontend (Interface Web)"
        FE_HTML["HTML: Principal.html"]:::frontend
        FE_CSS["CSS: Principal.css"]:::frontend
        FE_JS["JS: Principal.js"]:::frontend
        FE_COMB["Interface Web"]:::frontend
        FE_HTML --> FE_COMB
        FE_CSS --> FE_COMB
        FE_JS --> FE_COMB
    end

    %% Backend/API Subgraph
    subgraph "Backend/API"
        BE_EXP["Express App (app.js)"]:::backend
        BE_SRV["Server (server.js)"]:::backend
        BE_ROUTES["Rotas (/api/data) [promptRoutes.js]"]:::backend
        BE_PC["Controlador: promptController.js"]:::backend
        BE_AC["Controlador: abortController.js"]:::backend
        BE_DB["Configuração: db.js"]:::backend
        BE_UTIL["Utilitários: helper.js"]:::backend

        BE_EXP --> BE_SRV
        BE_SRV --> BE_ROUTES
        BE_ROUTES -->|"triggers"| BE_PC
        BE_ROUTES -->|"triggers"| BE_AC
        BE_PC -->|"uses"| BE_UTIL
        BE_AC -->|"uses"| BE_UTIL
        BE_PC -->|"invokes"| OLLAMA
        BE_AC -->|"invokes"| OLLAMA
        BE_PC -->|"queries"| BE_DB
        BE_AC -->|"queries"| BE_DB
        BE_DB -->|"connects"| DB
    end

    %% External Service: Ollama
    OLLAMA["Ollama - SQL Model"]:::external

    %% MySQL Database
    DB["Banco de Dados MySQL"]:::database

    %% Containerization Subgraph
    subgraph "Containerização"
        DOCKERFILE["Dockerfile"]:::container
        DOCKER_COMPOSE["docker-compose.yml"]:::container
    end

    %% Flow from Frontend to Backend
    FE_COMB -->|"POST/api/data"| BE_EXP

    %% Deployment association (dashed lines)
    DOCKERFILE -.-> BE_EXP
    DOCKER_COMPOSE -.-> DB

    %% Classes / Styles
    classDef frontend fill:#ffcc00,stroke:#333,stroke-width:2px;
    classDef backend fill:#66ccff,stroke:#333,stroke-width:2px;
    classDef external fill:#ff9966,stroke:#333,stroke-width:2px;
    classDef database fill:#aaffaa,stroke:#333,stroke-width:2px;
    classDef container fill:#cccccc,stroke:#333,stroke-width:2px;

    %% Click Events
    click FE_HTML "https://github.com/fernandofps20/ia-project/blob/main/public/html/Principal.html"
    click FE_CSS "https://github.com/fernandofps20/ia-project/blob/main/public/css/Principal.css"
    click FE_JS "https://github.com/fernandofps20/ia-project/blob/main/public/js/Principal.js"
    click BE_EXP "https://github.com/fernandofps20/ia-project/blob/main/src/app.js"
    click BE_SRV "https://github.com/fernandofps20/ia-project/blob/main/src/server.js"
    click BE_ROUTES "https://github.com/fernandofps20/ia-project/blob/main/src/routes/promptRoutes.js"
    click BE_PC "https://github.com/fernandofps20/ia-project/blob/main/src/controllers/promptController.js"
    click BE_AC "https://github.com/fernandofps20/ia-project/blob/main/src/controllers/abortController.js"
    click BE_DB "https://github.com/fernandofps20/ia-project/blob/main/src/config/db.js"
    click BE_UTIL "https://github.com/fernandofps20/ia-project/blob/main/src/utils/helper.js"
    click OLLAMA "https://github.com/fernandofps20/ia-project/tree/main/sqlModel"
    click DOCKERFILE "https://github.com/fernandofps20/ia-project/tree/main/Dockerfile"
    click DOCKER_COMPOSE "https://github.com/fernandofps20/ia-project/blob/main/docker-compose.yml"
```
