@nine-lab/nine-connector 0.1.1

package/README.md

@@ -0,0 +1,67 @@
+cat <<EOF > README.md
+# @nine-lab/nine-connector 🚀
+
+자연어 기반 SQL 생성 엔진(NineQuery)과 실제 데이터베이스 사이를 연결하는 **AI 전용 DB 커넥터 서비스**입니다.
+
+AI가 생성한 SQL을 안전하게 실행하고, 데이터베이스의 구조(Schema)를 AI에게 전달하기 위한 표준 API 환경을 제공합니다.
+
+---
+
+## 🌟 주요 기능
+
+*   **Multi-DB 지원**: MySQL, PostgreSQL, MariaDB와 즉시 연결 가능합니다.
+*   **스키마 자동 추출**: AI가 쿼리를 생성할 때 필요한 테이블 및 컬럼 정보를 API로 제공합니다.
+*   **보안 가드**: 오직 \`SELECT\` 쿼리만 실행할 수 있도록 설계되어 데이터 변조를 원천 차단합니다.
+*   **BigInt 대응**: 데이터베이스의 큰 숫자형(\`BigInt\`) 데이터를 JSON으로 안전하게 변환하여 반환합니다.
+
+---
+
+## 🛠 설치 및 실행 방법
+
+### 1. 전역(Global) 설치
+어느 경로에서나 명령어로 즉시 기동할 수 있도록 전역 설치를 권장합니다.
+
+\`\`\`bash
+npm install -g @nine-lab/nine-connector
+\`\`\`
+
+### 2. 환경 변수 설정 (\`.env\`)
+서버 실행 전, 데이터베이스 접속 정보를 설정해야 합니다. 실행할 경로에 \`.env\` 파일을 생성하거나 시스템 환경 변수를 설정하세요.
+
+\`\`\`env
+# 서버 포트 (기본값: 3000)
+SERVER_PORT=3000
+
+# 데이터베이스 설정
+DB_TYPE=mysql
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_USER=your_user
+DB_PASS=your_password
+DB_NAME=your_database
+\`\`\`
+
+### 3. 서버 기동
+설정이 완료되었다면 터미널에서 아래 명령어를 입력합니다.
+
+\`\`\`bash
+nine-connector
+\`\`\`
+
+---
+
+## 🔌 API 명세
+
+### 1. 데이터베이스 스키마 조회
+AI 모델이 현재 DB 구조를 학습할 수 있도록 메타데이터를 반환합니다.
+*   **Endpoint:** \`GET /api/schema\`
+
+### 2. SQL 쿼리 실행
+AI가 생성한 SQL을 실행합니다. 보안을 위해 **SELECT 문**만 허용됩니다.
+*   **Endpoint:** \`POST /api/query\`
+
+---
+
+## 📄 라이선스
+MIT © **nine-lab**
+EOF

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@nine-lab/nine-connector",
+  "version": "0.1.1",
+  "description": "NineQuery AI Connector for Database",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "nine-query-connector": "src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "build": "echo '빌드가 필요한 프로젝트라면 여기에 빌드 명령 작성'",
+    "release": "npm version patch && npm run build && npm publish"
+  },
+  "dependencies": {
+    "@langchain/core": "^1.1.44",
+    "@langchain/google-genai": "^2.1.30",
+    "@nine-lab/nine-util": "^0.9.35",
+    "cors": "^2.8.6",
+    "dotenv": "^16.4.5",
+    "express": "^4.22.1",
+    "mariadb": "^3.5.2",
+    "mysql2": "^3.9.7",
+    "pg": "^8.11.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/prompts/query-generator.md

@@ -0,0 +1,24 @@
+### SQL_GENERATE_PROMPT
+당신은 SQL 생성기입니다. 제공된 테이블의 컬럼 정보를 바탕으로 사용자의 질문에 답하는 최적의 SQL 쿼리를 작성하세요.
+
+[선택된 테이블 정보]
+{detailed_schema}
+
+[사용자 질문]
+"{question}"
+
+[데이터베이스 타입]
+{db_type}
+
+[응답 규칙]
+1. 반드시 JSON 형식으로만 응답하세요.
+2. SQL은 {db_type} 문법에 완벽하게 맞아야 하며, 즉시 실행 가능해야 합니다.
+3. 쿼리문 안에 마크다운 코드 블록(```sql)을 포함하지 마세요. 오직 순수 문자열로만 작성하세요.
+4. 사용자가 이해하기 쉽도록 쿼리에 대한 설명(explanation)을 친절하게 작성하세요.
+5. 존재하지 않는 컬럼이나 테이블은 절대 사용하지 마세요.
+
+[응답 포맷]
+{{
+"sql": "SELECT ... FROM ... WHERE ...",
+"explanation": "이 쿼리는 어떤 데이터를 어떻게 조회하는지에 대한 설명입니다."
+}}

package/prompts/table-filter.md

@@ -0,0 +1,21 @@
+### TABLE_FILTER_PROMPT
+당신은 SQL 전문가입니다. 사용자의 질문을 분석하여 데이터베이스에서 조회해야 할 필수 테이블들만 선정하세요.
+
+[전체 테이블 목록]
+{schema_summary}
+
+[사용자 질문]
+"{question}"
+
+[응답 규칙]
+1. 반드시 JSON 형식으로만 응답하세요.
+2. 질문을 해결하기 위해 반드시 참조해야 하는 테이블 이름만 'selected_tables' 배열에 넣으세요.
+3. 만약 질문이 데이터베이스 조회와 관련이 없거나, 제공된 테이블 정보로 답할 수 없다면 'is_executable'을 false로 설정하세요.
+4. 'reasoning' 필드에는 왜 해당 테이블들을 선택했는지 간략하게 설명하세요.
+
+[응답 포맷]
+{{
+"reasoning": "선정 이유를 여기에 작성",
+"selected_tables": ["table1", "table2"],
+"is_executable": true
+}}

package/src/ai/AIProcessor.js

@@ -0,0 +1,41 @@
+import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { JsonOutputParser } from "@langchain/core/output_parsers";
+
+export class AIProcessor {
+    #model;
+    #chains = {};
+    #parser;
+
+    constructor(apiKey, modelName = "gemini-2.5-flash") {
+        this.#model = new ChatGoogleGenerativeAI({
+            apiKey: apiKey,
+            model: modelName,
+            temperature: 0,
+        });
+        this.#parser = new JsonOutputParser();
+    }
+
+    registerChain(key, promptText) {
+        const promptTemplate = PromptTemplate.fromTemplate(promptText);
+        this.#chains[key] = promptTemplate.pipe(this.#model).pipe(this.#parser);
+        console.log(`[AIProcessor] ${key} 체인 등록 완료.`);
+    }
+
+    async filterTables(question, schemaSummary) {
+        if (!this.#chains['table-filter']) throw new Error("table-filter 체인 미등록");
+        return await this.#chains['table-filter'].invoke({
+            question,
+            schema_summary: JSON.stringify(schemaSummary, null, 2)
+        });
+    }
+
+    async generateSql(question, detailedSchema, dbType = 'mysql') {
+        if (!this.#chains['query-generator']) throw new Error("query-generator 체인 미등록");
+        return await this.#chains['query-generator'].invoke({
+            question,
+            detailed_schema: JSON.stringify(detailedSchema, null, 2),
+            db_type: dbType
+        });
+    }
+}

package/src/ai/AIService.js

@@ -0,0 +1,44 @@
+/**
+ * 자연어 질의 프로세스를 관리하는 서비스
+ */
+export class AIService {
+    constructor(db, ai) {
+        this.db = db;
+        this.ai = ai;
+    }
+
+    async processNaturalLanguageQuery(question) {
+        // 1) 전체 스키마 요약 정보 가져오기
+        const schemaSummary = await this.db.getTableSchema();
+
+        // 2) AI: 필요한 테이블 필터링
+        // AI 결과가 문자열일 경우를 대비해 파싱 로직이 AIProcessor에 없다면 여기서 보완 가능
+        const { tables } = await this.ai.filterTables(question, schemaSummary);
+
+        if (!tables || tables.length === 0) {
+            throw new Error("질문과 관련된 테이블을 찾을 수 없습니다.");
+        }
+
+        // 3) 상세 스키마 필터링 및 SQL 생성
+        const detailedSchema = schemaSummary.filter(t => tables.includes(t.tableName));
+        const { sql, explanation } = await this.ai.generateSql(
+            question,
+            detailedSchema,
+            process.env.DB_TYPE || 'mysql'
+        );
+
+        // 4) SQL 검증
+        if (!sql.trim().toLowerCase().startsWith("select")) {
+            throw new Error("보안 정책상 SELECT 쿼리만 실행 가능합니다.");
+        }
+
+        // 5) 쿼리 실행
+        const rows = await this.db.query(sql);
+
+        return {
+            sql,
+            explanation,
+            data: rows
+        };
+    }
+}

package/src/core/init.js

@@ -0,0 +1,140 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+
+/**
+ * 1. .env 파일 생성 담당 함수
+ */
+async function createEnvFile(rl) {
+    const questions = [
+        { key: 'SERVER_PORT', label: '1. 커넥터 서버 포트', default: '3000' },
+        { key: 'GEMINI_API_KEY', label: '2. Gemini API Key', default: '' },
+        { key: 'GEMINI_MODEL', label: '3. 사용할 모델', default: 'gemini-1.5-flash' },
+        { key: 'DB_TYPE', label: '4. DB 종류 (mysql, pg, mariadb)', default: 'mysql' },
+        { key: 'DB_HOST', label: '5. DB 호스트', default: '127.0.0.1' },
+        { key: 'DB_PORT', label: '6. DB 포트', default: '3306' },
+        { key: 'DB_USER', label: '7. DB 사용자 계정', default: 'root' },
+        { key: 'DB_PASS', label: '8. DB 비밀번호', default: '' },
+        { key: 'DB_NAME', label: '9. 데이터베이스 이름', default: '' },
+    ];
+
+    const envPath = path.join(process.cwd(), '.env');
+
+    if (fs.existsSync(envPath)) {
+        const overwrite = await new Promise((resolve) => {
+            rl.question('이미 .env 파일이 존재합니다. 덮어쓰시겠습니까? (y/n): ', resolve);
+        });
+        if (overwrite.toLowerCase() !== 'y') {
+            console.log('기존 .env 파일을 유지합니다.');
+            return true;
+        }
+    }
+
+    const answers = {};
+    for (const q of questions) {
+        const answer = await new Promise((resolve) => {
+            rl.question(`> ${q.label} [${q.default}]: `, resolve);
+        });
+        answers[q.key] = answer.trim() || q.default;
+    }
+
+    const envContent = Object.entries(answers)
+        .map(([key, val]) => `${key}=${val}`)
+        .join('\n');
+
+    fs.writeFileSync(envPath, envContent);
+    console.log('.env 파일 생성이 완료되었습니다.');
+    return true;
+}
+
+/**
+ * 2. 프롬프트 파일(.md) 생성 담당 함수
+ */
+function createPromptFiles() {
+    const promptDir = path.join(process.cwd(), 'prompts');
+
+    if (!fs.existsSync(promptDir)) {
+        fs.mkdirSync(promptDir, { recursive: true });
+    }
+
+    const prompts = {
+        'table-filter.md': `## TABLE_FILTER_PROMPT
+당신은 SQL 전문가입니다. 사용자의 질문을 분석하여 데이터베이스에서 조회해야 할 필수 테이블들만 선정하세요.
+
+[전체 테이블 목록]
+{schema_summary}
+
+[사용자 질문]
+"{question}"
+
+[응답 규칙]
+1. 반드시 JSON 형식으로만 응답하세요.
+2. 질문을 해결하기 위해 반드시 참조해야 하는 테이블 이름만 'selected_tables' 배열에 넣으세요.
+3. 만약 질문이 데이터베이스 조회와 관련이 없거나, 제공된 테이블 정보로 답할 수 없다면 'is_executable'을 false로 설정하세요.
+4. 'reasoning' 필드에는 왜 해당 테이블들을 선택했는지 간략하게 설명하세요.
+
+[응답 포맷]
+{{
+"reasoning": "선정 이유를 여기에 작성",
+"selected_tables": ["table1", "table2"],
+"is_executable": true
+}}`,
+
+        'query-generator.md': `## SQL_GENERATE_PROMPT
+당신은 SQL 생성기입니다. 제공된 테이블의 컬럼 정보를 바탕으로 사용자의 질문에 답하는 최적의 SQL 쿼리를 작성하세요.
+
+[선택된 테이블 정보]
+{detailed_schema}
+
+[사용자 질문]
+"{question}"
+
+[데이터베이스 타입]
+{db_type}
+
+[응답 규칙]
+1. 반드시 JSON 형식으로만 응답하세요.
+2. SQL은 {db_type} 문법에 완벽하게 맞아야 하며, 즉시 실행 가능해야 합니다.
+3. 쿼리문 안에 마크다운 코드 블록(\`\`\`sql)을 포함하지 마세요. 오직 순수 문자열로만 작성하세요.
+4. 사용자가 이해하기 쉽도록 쿼리에 대한 설명(explanation)을 친절하게 작성하세요.
+5. 존재하지 않는 컬럼이나 테이블은 절대 사용하지 마세요.
+
+[응답 포맷]
+{{
+"sql": "SELECT ... FROM ... WHERE ...",
+"explanation": "이 쿼리는 어떤 데이터를 어떻게 조회하는지에 대한 설명입니다."
+}}`
+    };
+
+    Object.entries(prompts).forEach(([filename, content]) => {
+        const filePath = path.join(promptDir, filename);
+        fs.writeFileSync(filePath, content.trim());
+    });
+
+    console.log('프롬프트 파일 생성이 완료되었습니다.');
+}
+
+/**
+ * 메인 실행 함수
+ */
+export async function runInit() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    try {
+        console.log('설정 초기화를 시작합니다.');
+
+        const success = await createEnvFile(rl);
+        if (success) {
+            createPromptFiles();
+            console.log('모든 초기화 작업이 완료되었습니다.');
+            console.log('nine-connector 를 입력하여 서버를 실행하세요.');
+        }
+    } catch (err) {
+        console.error('초기화 중 오류 발생:', err.message);
+    } finally {
+        rl.close();
+    }
+}

package/src/database/config/database.js

@@ -0,0 +1,42 @@
+import * as mariadb from 'mariadb';
+
+// [중요] .env에서 가져온 값들의 양끝 공백을 제거하고 타입을 맞춥니다.
+const dbConfig = {
+    host: process.env.DB_HOST?.trim(),           // 혹시 모를 줄바꿈/공백 제거
+    port: Number(process.env.DB_PORT?.trim()) || 3306, // 확실하게 숫자로 변환
+    user: process.env.DB_USER?.trim(),
+    password: process.env.DB_PASS?.trim(),       // 특수문자가 포함된 경우 trim 필수
+    database: process.env.DB_NAME?.trim(),
+    connectionLimit: 10,
+    connectTimeout: 10000
+};
+
+// 로그로 실제 값이 하드코딩과 완벽히 일치하는지 대조해보세요.
+console.log("--- DB Config Check ---");
+console.log("Host:", `[${dbConfig.host}]`); // 대괄호 안에 공백이 있는지 확인
+console.log("Port Type:", typeof dbConfig.port); // number여야 함
+console.log("--- ---------------- ---");
+
+const pool = mariadb.createPool(dbConfig);
+
+export const getConnection = async () => {
+    try {
+        return await pool.getConnection();
+    } catch (err) {
+        console.error("❌ DB 연결 실패:", err);
+        throw err;
+    }
+};
+
+export default pool;
+
+/**
+const pool = mariadb.createPool({
+    host: "mariadb.artygentech.com",
+    port: 3306,
+    user: "root",
+    password: "aglab123!@#",
+    database: "aidemo",
+    connectionLimit: 10,
+    connectTimeout: 10000
+}); */

package/src/database/core/DatabaseManager.js

@@ -0,0 +1,88 @@
+import PoolManager from './PoolManager.js';
+import Dialects from './Dialects.js'; // 쿼리 사전 임포트
+
+class DatabaseManager {
+    constructor(config) {
+        this.config = config;
+        this.pool = null;
+        this.type = config.type?.toLowerCase();
+        this.dialect = Dialects[this.type];
+
+        if (!this.dialect) {
+            throw new Error(`❌ Unsupported Dialect for: ${this.type}`);
+        }
+    }
+
+    /**
+     * DatabaseFactory의 init() 역할을 수행합니다.
+     */
+    async connect() {
+        try {
+            // Pool 생성은 전적으로 PoolManager에게 맡깁니다.
+            this.pool = PoolManager.createPool(this.config);
+
+            // 단순 연결 확인 쿼리
+            await this.query('SELECT 1');
+            console.log(`✅ [${this.type}] Database connection successful.`);
+        } catch (error) {
+            console.error(`❌ [${this.type}] Connection failed:`, error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * DB별 결과 포맷 차이를 여기서 해결합니다. (데이터 배열만 반환)
+     */
+    // DatabaseManager.js 수정
+    async query(sql, params = []) {
+        if (!this.pool) throw new Error("Database not connected.");
+
+        const result = await this.pool.query(sql, params);
+
+        if (this.type === 'postgres') {
+            return result.rows;
+        } else {
+            // 만약 result[0]이 또 배열이라면(mysql2 이중 배열), 0번 인덱스를 반환
+            // 아니라면 result를 그대로 반환
+            return (Array.isArray(result) && Array.isArray(result[0]))
+                ? result[0]
+                : result;
+        }
+    }
+
+    /**
+     * AI 가공을 위해 스키마 데이터를 구조화합니다.
+     * 결과 예시:
+     * {
+     *   "orders": {
+     *      "description": "주문 기본 정보 테이블",
+     *      "columns": [{ "column": "id", "type": "int" }, ...]
+     *   }
+     * }
+     */
+    async getTableSchema() {
+        const rows = await this.query(this.dialect.schemaQuery);
+
+        return rows.reduce((acc, row) => {
+            const { table_name, table_comment, column_name, data_type } = row;
+
+            // 테이블이 처음 등장하면 초기화
+            if (!acc[table_name]) {
+                acc[table_name] = {
+                    description: table_comment || "", // 테이블 설명 추가
+                    columns: []
+                };
+            }
+
+            // 컬럼 정보 push
+            acc[table_name].columns.push({
+                column: column_name,
+                type: data_type
+            });
+
+            return acc;
+        }, {});
+    }
+}
+
+export default DatabaseManager;

package/src/database/core/Dialects.js

@@ -0,0 +1,59 @@
+const Dialects = {
+    // MySQL 추가 (MariaDB와 동일)
+    mysql: {
+        schemaQuery: `
+            SELECT
+                c.TABLE_NAME as table_name,
+                t.TABLE_COMMENT as table_comment,
+                c.COLUMN_NAME as column_name,
+                c.DATA_TYPE as data_type
+            FROM information_schema.columns c
+                     INNER JOIN information_schema.tables t
+                                ON c.TABLE_NAME = t.TABLE_NAME
+                                    AND c.TABLE_SCHEMA = t.TABLE_SCHEMA
+            WHERE c.TABLE_SCHEMA = DATABASE()
+            ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`
+    },
+    mariadb: {
+        schemaQuery: `
+            SELECT
+                c.TABLE_NAME as table_name,
+                t.TABLE_COMMENT as table_comment,
+                c.COLUMN_NAME as column_name,
+                c.DATA_TYPE as data_type
+            FROM information_schema.columns c
+                     INNER JOIN information_schema.tables t
+                                ON c.TABLE_NAME = t.TABLE_NAME
+                                    AND c.TABLE_SCHEMA = t.TABLE_SCHEMA
+            WHERE c.TABLE_SCHEMA = DATABASE()
+            ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION`
+    },
+    postgres: {
+        schemaQuery: `
+            SELECT
+                t.table_name,
+                obj_description(pgc.oid, 'pg_class') AS table_comment,
+                c.column_name,
+                c.data_type
+            FROM information_schema.tables t
+                     JOIN information_schema.columns c ON t.table_name = c.table_name
+                     JOIN pg_class pgc ON t.table_name = pgc.relname
+            WHERE t.table_schema = 'public'
+            ORDER BY t.table_name, c.ordinal_position`
+    },
+    oracle: {
+        schemaQuery: `
+            SELECT 
+                t.TABLE_NAME as table_name, 
+                tc.COMMENTS as table_comment,
+                c.COLUMN_NAME as column_name, 
+                c.DATA_TYPE as data_type
+            FROM ALL_TABLES t
+            JOIN ALL_TAB_COLUMNS c ON t.TABLE_NAME = c.TABLE_NAME AND t.OWNER = c.OWNER
+            LEFT JOIN ALL_TAB_COMMENTS tc ON t.TABLE_NAME = tc.TABLE_NAME AND t.OWNER = tc.OWNER
+            WHERE t.OWNER = (SELECT USER FROM DUAL) -- 현재 접속한 스키마만 조회
+            ORDER BY t.TABLE_NAME, c.COLUMN_ID`
+    }
+};
+
+export default Dialects;

package/src/database/core/PoolManager.js

@@ -0,0 +1,49 @@
+import * as mariadb from 'mariadb';
+import pg from 'pg';
+
+class PoolManager {
+    /**
+     * DB 타입에 맞는 커넥션 풀을 생성하여 반환합니다.
+     */
+    static createPool(config) {
+        const type = config?.type?.toLowerCase();
+
+        switch (type) {
+            case 'mariadb':
+            case 'mysql':
+                return this.#createMariaDBPool(config);
+            case 'postgres':
+            case 'postgresql':
+                return this.#createPostgresPool(config);
+            default:
+                throw new Error(`[PoolManager] Unsupported DB_TYPE: ${type}`);
+        }
+    }
+
+    static #createMariaDBPool(config) {
+        return mariadb.createPool({
+            host: config.host,
+            port: config.port,
+            user: config.user,
+            password: config.password,
+            database: config.database,
+            connectionLimit: 10,
+            connectTimeout: 10000
+        });
+    }
+
+    static #createPostgresPool(config) {
+        const { Pool } = pg;
+        return new Pool({
+            host: config.host,
+            port: config.port,
+            user: config.user,
+            password: config.password,
+            database: config.database,
+            max: 10,
+            idleTimeoutMillis: 30000
+        });
+    }
+}
+
+export default PoolManager;

package/src/index.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import fs from 'fs';
+import path from 'path'; // path 모듈 추가
+import DatabaseManager from './database/core/DatabaseManager.js';
+import { runInit } from './core/init.js';
+import { AIProcessor } from './ai/AIProcessor.js';
+import { AIService } from './ai/AIService.js';
+
+/**
+ * 서버 실행 로직
+ */
+async function bootstrap() {
+    // 1. 필수 환경 변수 체크
+    if (!process.env.DB_HOST || !process.env.DB_NAME) {
+        console.error("설정 정보가 부족합니다. 'nine-connector init'을 먼저 실행해주세요.");
+        process.exit(1);
+    }
+
+    const app = express();
+    const SERVER_PORT = process.env.SERVER_PORT || 3000;
+
+    // 2. DB 매니저 초기화
+    const db = new DatabaseManager({
+        type: process.env.DB_TYPE,
+        host: process.env.DB_HOST,
+        port: Number(process.env.DB_PORT),
+        user: process.env.DB_USER,
+        password: process.env.DB_PASS,
+        database: process.env.DB_NAME
+    });
+
+    // BigInt 직렬화 설정
+    BigInt.prototype.toJSON = function() { return this.toString(); };
+
+    app.use(cors());
+    app.use(express.json());
+
+    // 3. AI 프로세서 초기화 및 체인 등록
+    const ai = new AIProcessor(process.env.GEMINI_API_KEY, process.env.GEMINI_MODEL);
+
+    try {
+        // init.js에서 생성한 경로와 일치시킵니다. (보통 루트의 prompts 폴더)
+        const promptPath = path.join(process.cwd(), 'prompts');
+
+        const tableFilterPrompt = fs.readFileSync(
+            path.join(promptPath, 'table-filter.md'), 'utf-8'
+        );
+        const queryGenPrompt = fs.readFileSync(
+            path.join(promptPath, 'query-generator.md'), 'utf-8'
+        );
+
+        ai.registerChain('table-filter', tableFilterPrompt);
+        ai.registerChain('query-generator', queryGenPrompt);
+
+        console.log("모든 AI 체인이 준비되었습니다.");
+    } catch (err) {
+        console.error("체인 등록 중 오류 발생 (프롬프트 파일을 확인하세요):", err.message);
+        process.exit(1);
+    }
+
+    // 서비스 인스턴스 생성
+    const aiService = new AIService(db, ai);
+
+    // [API] 자연어 질의 엔드포인트
+    app.post('/api/ask', async (req, res) => {
+        const { question } = req.body;
+        if (!question) {
+            return res.status(400).json({ success: false, error: "질문을 입력해주세요." });
+        }
+
+        try {
+            const result = await aiService.processNaturalLanguageQuery(question);
+            res.json({ success: true, ...result });
+        } catch (err) {
+            console.error("AI 질의 처리 중 오류:", err);
+            res.status(500).json({
+                success: false,
+                error: err.message || "쿼리 처리 중 서버 오류가 발생했습니다."
+            });
+        }
+    });
+
+    try {
+        await db.connect();
+        console.log("데이터베이스 연결 성공");
+
+        // 스키마 조회 API
+        app.get('/api/schema', async (req, res) => {
+            try {
+                const schema = await db.getTableSchema();
+                res.json({ success: true, data: schema });
+            } catch (err) {
+                res.status(500).json({ success: false, error: "Failed to fetch schema" });
+            }
+        });
+
+        // 쿼리 실행 API
+        app.post('/api/query', async (req, res) => {
+            const { sql } = req.body;
+            if (!sql || !sql.trim().toLowerCase().startsWith("select")) {
+                return res.status(400).json({ success: false, error: "Only SELECT queries are allowed" });
+            }
+
+            try {
+                const rows = await db.query(sql);
+                res.json({ success: true, data: rows });
+            } catch (err) {
+                res.status(500).json({ success: false, error: "Database query error" });
+            }
+        });
+
+        app.listen(SERVER_PORT, () => {
+            console.log(`NineQuery Connector running on http://localhost:${SERVER_PORT}`);
+        });
+    } catch (error) {
+        console.error("서버 기동 실패:", error.message);
+        process.exit(1);
+    }
+}
+
+// ----------------------
+// 실행 분기 처리
+// ----------------------
+const args = process.argv.slice(2);
+
+if (args.includes('init')) {
+    runInit();
+} else {
+    bootstrap();
+}