graph TD
A[用户输入] --> B{NLP解析}
B --> C[SQL生成]
C --> D[安全验证]
D --> E[数据库查询]
E --> F[结果处理]
F --> G[自然语言输出]

```python
# config.yaml
database:
type: mysql
host: 192.168.1.100
port: 3306
user: mes_user
password: secure_password
dbname: production_db
allowed_tables: ["work_orders", "production_lines"]
max_rows: 1000

model:
local_path: /models/deepseek-chat-7b
device: cuda:0
max_length: 512
```

import torch
from sqlalchemy import create_engine, MetaData
from transformers import AutoTokenizer, AutoModelForCausalLM

class MESQueryProcessor:
def __init__(self, config_path):
# 初始化数据库连接
self.db_engine = create_engine(
f"{config['database']['type']}://{config['database']['user']}:{config['database']['password']}"
f"@{config['database']['host']}:{config['database']['port']}/{config['database']['dbname']}"
)
self.metadata = MetaData()
self.metadata.reflect(bind=self.db_engine)

# 加载本地模型
self.tokenizer = AutoTokenizer.from_pretrained(config['model']['local_path'])
self.model = AutoModelForCausalLM.from_pretrained(
config['model']['local_path'],
device_map=config['model']['device'],
torch_dtype=torch.float16
)

# 构建Schema提示
self.schema_prompt = self._build_schema_prompt()

def _build_schema_prompt(self):
"""生成数据库结构描述"""
schema_info = []
for table in self.metadata.tables.values():
if table.name in config['database']['allowed_tables']:
columns = [f"{col.name} ({str(col.type)})" for col in table.columns]
schema_info.append(f"表 {table.name}: {', '.join(columns)}")
return "\n".join(schema_info)

def generate_sql(self, question):
"""生成安全的SQL查询"""
prompt = f"""
数据库结构:
{self.schema_prompt}

请将以下问题转换为安全且符合规范的SQL查询:
Q: {question}
A: SELECT
"""
inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
outputs = self.model.generate(
inputs.input_ids,
max_length=config['model']['max_length'],
temperature=0.1,
num_return_sequences=1
)
generated_sql = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
return self._sanitize_sql(generated_sql)

def _sanitize_sql(self, sql):
"""SQL安全过滤"""
# 删除危险操作
forbidden_keywords = ['INSERT', 'UPDATE', 'DELETE', 'DROP', 'TRUNCATE']
for keyword in forbidden_keywords:
if keyword in sql.upper():
raise SecurityError(f"检测到非法操作: {keyword}")
# 限制返回行数
if 'LIMIT' not in sql.upper():
sql += f" LIMIT {config['database']['max_rows']}"
return sql

def execute_query(self, sql):
"""执行查询并格式化结果"""
with self.db_engine.connect() as conn:
result = conn.execute(sql)
columns = result.keys()
data = result.fetchall()
return {"columns": columns, "data": data}

def process_query(self, question):
"""完整处理流程"""
try:
generated_sql = self.generate_sql(question)
query_result = self.execute_query(generated_sql)
return self.format_response(query_result)
except Exception as e:
return f"查询失败: {str(e)}"

def format_response(self, result):
"""结果自然语言化"""
columns = result['columns']
data = result['data']

# 生成自然语言描述
summary = f"找到 {len(data)} 条记录:\n"
summary += ", ".join(columns) + "\n"

# 添加关键数据示例
for row in data[:3]:
summary += " | ".join(str(x) for x in row) + "\n"
if len(data) > 3:
summary += f"...(共 {len(data)} 条)"
return summary

# 初始化处理器
processor = MESQueryProcessor("config.yaml")
```

from sqlparse import parse, tokens
from sqlparse.sql import IdentifierList, Identifier

class SQLValidator:
@staticmethod
def validate(sql):
"""多层SQL验证"""
parsed = parse(sql)[0]

# 验证语句类型
if parsed.get_type() != 'SELECT':
raise SecurityError("只允许SELECT查询")

# 验证授权表访问
allowed_tables = config['database']['allowed_tables']
for token in parsed.tokens:
if isinstance(token, IdentifierList):
for identifier in token.get_identifiers():
if identifier.get_real_name() not in allowed_tables:
raise SecurityError(f"禁止访问表 {identifier.get_real_name()}")
elif isinstance(token, Identifier):
if token.get_real_name() not in allowed_tables:
raise SecurityError(f"禁止访问表 {token.get_real_name()}")
```

if __name__ == "__main__":
question = "请列出所有状态为正在生产的工单，包含工单号、产品型号和当前进度"

response = processor.process_query(question)
print("自然语言回答:")
print(response)

# 输出示例：
"""
找到 15 条记录:
work_order_id, product_model, progress
WO-202307-001 | Model-X1 | 75%
WO-202307-002 | Model-X2 | 63%
WO-202307-003 | Model-X3 | 89%
...(共 15 条)

from functools import lru_cache

class CachedProcessor(MESQueryProcessor):
@lru_cache(maxsize=100)
def process_query(self, question):
return super().process_query(question)
```

import threading
import time

class RealTimeUpdater:
def __init__(self, processor):
self.processor = processor
self.cache = {}
self.running = True
threading.Thread(target=self._update_loop).start()

def _update_loop(self):
while self.running:
# 每5分钟刷新关键表
try:
with self.processor.db_engine.connect() as conn:
for table in config['database']['allowed_tables']:
conn.execute(f"SELECT 1 FROM {table} LIMIT 1")
time.sleep(300)
except Exception as e:
print(f"刷新失败: {str(e)}")

syntax = "proto3";

service MESQuery {
    rpc Query (QueryRequest) returns (QueryResponse);
}

message QueryRequest {
    string question = 1;
}

message QueryResponse {
    string answer = 1;
    string sql = 2;
    int32 result_count = 3;
}

```dockerfile
FROM nvidia/cuda:12.1.1-base-ubuntu22.04

RUN apt-get update && \
apt-get install -y python3.10 python3-pip && \
update-alternatives --install /usr/bin/python python /usr/bin/python3.10 1

COPY requirements.txt .
RUN pip install -r requirements.txt

ENV PYTHONUNBUFFERED=1
EXPOSE 50051

CMD ["python", "grpc_server.py"]
```

from ldap3 import Server, Connection

class AuthManager:
    def __init__(self):
        self.ldap_server = Server('ldap://company.com')
        
    def check_permission(self, user, question):
        # 连接LDAP验证用户权限
        with Connection(self.ldap_server, user=user.uid, password=user.password) as conn:
            if conn.bind():
                # 检查用户所属组是否有权限
                if 'mes_viewer' in user.groups:
                    return True
        return False

用户输入： "显示今天良品率低于95%的生产线"
转换SQL： SELECT line_id, product_type, yield_rate 
FROM production_lines 
WHERE DATE(record_time) = CURDATE() 
AND yield_rate < 0.95
LIMIT 1000