Initial commit

2025-02-17 10:34:35 +08:00 · 2025-02-17 10:34:35 +08:00 · 6a7283484a
commit 6a7283484a
52 changed files with 4830 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,149 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+nohup.out
+cert/
+pg-data/pgdata/
+pg-data/*.xlsx
+pg-data/*.rar
+log/
+output/
+config/wxbiz-access-token
+test/
+chroma_db/
--- a/.htaccess
+++ b/.htaccess
@ -0,0 +1 @@
+# 请将伪静态规则或自定义Apache配置填写到此处
--- a/README.md
+++ b/README.md
@ -0,0 +1,36 @@
+# qwensql
+
+#### 介绍
+
+#### 软件架构
+软件架构说明
+
+
+#### 安装教程
+
+1.  xxxx
+2.  xxxx
+3.  xxxx
+
+#### 使用说明
+
+1.  xxxx
+2.  xxxx
+3.  xxxx
+
+#### 参与贡献
+
+1.  Fork 本仓库
+2.  新建 Feat_xxx 分支
+3.  提交代码
+4.  新建 Pull Request
+
+
+#### 特技
+
+1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
+2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
+3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
+4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
+5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
+6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)
--- a/bizwechat/init.py
+++ b/bizwechat/init.py
@ -0,0 +1,300 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+""" 微信企业后台 接口.
+@copyright: Copyright (c) 1998-2014 Tencent Inc.
+
+"""
+# ------------------------------------------------------------------------
+import logging
+import base64
+import random
+import hashlib
+import time
+import struct
+from Crypto.Cipher import AES
+import xml.etree.cElementTree as ET
+import socket
+
+
+
+#########################################################################
+# Author: jonyqin
+# Created Time: Thu 11 Sep 2014 01:53:58 PM CST
+# File Name: ierror.py
+# Description:定义错误码含义 
+#########################################################################
+WXBizMsgCrypt_OK = 0
+WXBizMsgCrypt_ValidateSignature_Error = -40001
+WXBizMsgCrypt_ParseXml_Error = -40002
+WXBizMsgCrypt_ComputeSignature_Error = -40003
+WXBizMsgCrypt_IllegalAesKey = -40004
+WXBizMsgCrypt_ValidateCorpid_Error = -40005
+WXBizMsgCrypt_EncryptAES_Error = -40006
+WXBizMsgCrypt_DecryptAES_Error = -40007
+WXBizMsgCrypt_IllegalBuffer = -40008
+WXBizMsgCrypt_EncodeBase64_Error = -40009
+WXBizMsgCrypt_DecodeBase64_Error = -40010
+WXBizMsgCrypt_GenReturnXml_Error = -40011
+
+"""
+关于Crypto.Cipher模块，ImportError: No module named 'Crypto'解决方案
+请到官方网站 https://www.dlitz.net/software/pycrypto/ 下载pycrypto。
+下载后，按照README中的“Installation”小节的提示进行pycrypto安装。
+"""
+
+
+class FormatException(Exception):
+    pass
+
+
+def throw_exception(message, exception_class=FormatException):
+    """my define raise exception function"""
+    raise exception_class(message)
+
+
+class SHA1:
+    """计算企业微信的消息签名接口"""
+
+    def getSHA1(self, token, timestamp, nonce, encrypt):
+        """用SHA1算法生成安全签名
+        @param token:  票据
+        @param timestamp: 时间戳
+        @param encrypt: 密文
+        @param nonce: 随机字符串
+        @return: 安全签名
+        """
+        try:
+            sortlist = [token, timestamp, nonce, encrypt]
+            sortlist.sort()
+            sha = hashlib.sha1()
+            sha.update("".join(sortlist).encode())
+            return WXBizMsgCrypt_OK, sha.hexdigest()
+        except Exception as e:
+            logger = logging.getLogger('sqlcode')
+            logger.error(e)
+            return WXBizMsgCrypt_ComputeSignature_Error, None
+
+
+class XMLParse:
+    """提供提取消息格式中的密文及生成回复消息格式的接口"""
+
+    # xml消息模板
+    AES_TEXT_RESPONSE_TEMPLATE = """<xml>
+<Encrypt><![CDATA[%(msg_encrypt)s]]></Encrypt>
+<MsgSignature><![CDATA[%(msg_signaturet)s]]></MsgSignature>
+<TimeStamp>%(timestamp)s</TimeStamp>
+<Nonce><![CDATA[%(nonce)s]]></Nonce>
+</xml>"""
+
+    def extract(self, xmltext):
+        """提取出xml数据包中的加密消息
+        @param xmltext: 待提取的xml字符串
+        @return: 提取出的加密消息字符串
+        """
+        try:
+            xml_tree = ET.fromstring(xmltext)
+            encrypt = xml_tree.find("Encrypt")
+            return WXBizMsgCrypt_OK, encrypt.text
+        except Exception as e:
+            logger = logging.getLogger('sqlcode')
+            logger.error(e)
+            return WXBizMsgCrypt_ParseXml_Error, None
+
+    def generate(self, encrypt, signature, timestamp, nonce):
+        """生成xml消息
+        @param encrypt: 加密后的消息密文
+        @param signature: 安全签名
+        @param timestamp: 时间戳
+        @param nonce: 随机字符串
+        @return: 生成的xml字符串
+        """
+        resp_dict = {
+            'msg_encrypt': encrypt,
+            'msg_signaturet': signature,
+            'timestamp': timestamp,
+            'nonce': nonce,
+        }
+        resp_xml = self.AES_TEXT_RESPONSE_TEMPLATE % resp_dict
+        return resp_xml
+
+
+class PKCS7Encoder():
+    """提供基于PKCS7算法的加解密接口"""
+
+    block_size = 32
+
+    def encode(self, text):
+        """ 对需要加密的明文进行填充补位
+        @param text: 需要进行填充补位操作的明文
+        @return: 补齐明文字符串
+        """
+        text_length = len(text)
+        # 计算需要填充的位数
+        amount_to_pad = self.block_size - (text_length % self.block_size)
+        if amount_to_pad == 0:
+            amount_to_pad = self.block_size
+        # 获得补位所用的字符
+        pad = chr(amount_to_pad)
+        return text + (pad * amount_to_pad).encode()
+
+    def decode(self, decrypted):
+        """删除解密后明文的补位字符
+        @param decrypted: 解密后的明文
+        @return: 删除补位字符后的明文
+        """
+        pad = ord(decrypted[-1])
+        if pad < 1 or pad > 32:
+            pad = 0
+        return decrypted[:-pad]
+
+
+class Prpcrypt(object):
+    """提供接收和推送给企业微信消息的加解密接口"""
+
+    def __init__(self, key):
+
+        # self.key = base64.b64decode(key+"=")
+        self.key = key
+        # 设置加解密模式为AES的CBC模式
+        self.mode = AES.MODE_CBC
+
+    def encrypt(self, text, receiveid):
+        """对明文进行加密
+        @param text: 需要加密的明文
+        @return: 加密得到的字符串
+        """
+        # 16位随机字符串添加到明文开头
+        text = text.encode()
+        text = self.get_random_str() + struct.pack("I", socket.htonl(len(text))) + text + receiveid.encode()
+
+        # 使用自定义的填充方式对明文进行补位填充
+        pkcs7 = PKCS7Encoder()
+        text = pkcs7.encode(text)
+        # 加密
+        cryptor = AES.new(self.key, self.mode, self.key[:16])
+        try:
+            ciphertext = cryptor.encrypt(text)
+            # 使用BASE64对加密后的字符串进行编码
+            return WXBizMsgCrypt_OK, base64.b64encode(ciphertext)
+        except Exception as e:
+            logger = logging.getLogger('sqlcode')
+            logger.error(e)
+            return WXBizMsgCrypt_EncryptAES_Error, None
+
+    def decrypt(self, text, receiveid):
+        """对解密后的明文进行补位删除
+        @param text: 密文
+        @return: 删除填充补位后的明文
+        """
+        try:
+            cryptor = AES.new(self.key, self.mode, self.key[:16])
+            # 使用BASE64对密文进行解码，然后AES-CBC解密
+            plain_text = cryptor.decrypt(base64.b64decode(text))
+        except Exception as e:
+            logger = logging.getLogger('sqlcode')
+            logger.error(e)
+            return WXBizMsgCrypt_DecryptAES_Error, None
+        try:
+            pad = plain_text[-1]
+            # 去掉补位字符串
+            # pkcs7 = PKCS7Encoder()
+            # plain_text = pkcs7.encode(plain_text)
+            # 去除16位随机字符串
+            content = plain_text[16:-pad]
+            xml_len = socket.ntohl(struct.unpack("I", content[: 4])[0])
+            xml_content = content[4: xml_len + 4]
+            from_receiveid = content[xml_len + 4:]
+        except Exception as e:
+            logger = logging.getLogger('sqlcode')
+            logger.error(e)
+            return WXBizMsgCrypt_IllegalBuffer, None
+
+        if from_receiveid.decode('utf8') != receiveid:
+            return WXBizMsgCrypt_ValidateCorpid_Error, None
+        return 0, xml_content
+
+    def get_random_str(self):
+        """ 随机生成16位字符串
+        @return: 16位字符串
+        """
+        return str(random.randint(1000000000000000, 9999999999999999)).encode()
+
+
+class WXBizMsgCrypt(object):
+    # 构造函数
+    def __init__(self, sToken, sEncodingAESKey, sReceiveId):
+        try:
+            self.key = base64.b64decode(sEncodingAESKey + "=")
+            assert len(self.key) == 32
+        except:
+            throw_exception("[error]: EncodingAESKey unvalid !", FormatException)
+            # return ierror.WXBizMsgCrypt_IllegalAesKey,None
+        self.m_sToken = sToken
+        self.m_sReceiveId = sReceiveId
+
+        # 验证URL
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sEchoStr: 随机串，对应URL参数的echostr
+        # @param sReplyEchoStr: 解密之后的echostr，当return返回0时有效
+        # @return：成功0，失败返回对应的错误码
+
+    def VerifyURL(self, sMsgSignature, sTimeStamp, sNonce, sEchoStr):
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, sEchoStr)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, sReplyEchoStr = pc.decrypt(sEchoStr, self.m_sReceiveId)
+        return ret, sReplyEchoStr
+
+    def EncryptMsg(self, sReplyMsg, sNonce, timestamp=None):
+        # 将企业回复用户的消息加密打包
+        # @param sReplyMsg: 企业号待回复用户的消息，xml格式的字符串
+        # @param sTimeStamp: 时间戳，可以自己生成，也可以用URL参数的timestamp,如为None则自动用当前时间
+        # @param sNonce: 随机串，可以自己生成，也可以用URL参数的nonce
+        # sEncryptMsg: 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串,
+        # return：成功0，sEncryptMsg,失败返回对应的错误码None
+        pc = Prpcrypt(self.key)
+        ret, encrypt = pc.encrypt(sReplyMsg, self.m_sReceiveId)
+        encrypt = encrypt.decode('utf8')
+        if ret != 0:
+            return ret, None
+        if timestamp is None:
+            timestamp = str(int(time.time()))
+        # 生成安全签名
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, timestamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        xmlParse = XMLParse()
+        return ret, xmlParse.generate(encrypt, signature, timestamp, sNonce)
+
+    def DecryptMsg(self, sPostData, sMsgSignature, sTimeStamp, sNonce):
+        # 检验消息的真实性，并且获取解密后的明文
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sPostData: 密文，对应POST请求的数据
+        #  xml_content: 解密后的原文，当return返回0时有效
+        # @return: 成功0，失败返回对应的错误码
+        # 验证安全签名
+        xmlParse = XMLParse()
+        ret, encrypt = xmlParse.extract(sPostData)
+        if ret != 0:
+            return ret, None
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, xml_content = pc.decrypt(encrypt, self.m_sReceiveId)
+        return ret, xml_content
+    
+
--- a/charts.py
+++ b/charts.py
@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+import asyncio
+from datetime import datetime
+from http.client import HTTPException
+
+from openpyxl.reader.excel import load_workbook
+from starlette.responses import JSONResponse
+from fastapi import FastAPI
+import config
+
+app = FastAPI()
+
+def json_serializable(obj):
+    if isinstance(obj, datetime):
+        return obj.isoformat()  # 转换为 ISO 格式的字符串
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+@app.get("/read-excel")
+async def read_excel_rows():
+    try:
+        rows="1,2,3,4,5"
+        # 加载Excel工作簿
+        file_path =config.osp.join(config.BASE_DIR, 'output/','4834ed97e0ba477b9d239560e4b12be6.xlsx')
+        workbook = load_workbook(filename=file_path)
+        sheet = workbook.active  # 或者使用workbook.get_sheet_by_name('Sheet1')
+
+        # 获取要读取的行号列表
+        # row_numbers = [int(r) for r in rows.split(',') if r.isdigit()]
+
+        # 读取指定行的数据
+        data = []
+
+        for row in sheet:
+            row_data = [json_serializable(cell.value) if isinstance(cell.value, datetime) else cell.value for cell in row]
+            data.append(row_data)
+        return JSONResponse(content={"data": data})
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == '__main__':
+
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=9001)
--- a/config/init.py
+++ b/config/init.py
@ -0,0 +1,134 @@
+from os import path as osp
+import rtoml
+from typing import Any, Optional
+import requests  
+import time  
+from threading import Lock 
+from os import environ
+from dataclasses import dataclass
+
+ENVIRONMENT = environ.get('ENVIRONMENT', 'development')
+CONFIG_DIR = osp.dirname(__file__)
+BASE_DIR = osp.realpath(osp.join(CONFIG_DIR, '..'))
+
+def config_file(*paths):
+    return osp.join(CONFIG_DIR, ENVIRONMENT, *paths)
+
+def load_config(*paths) -> dict[str, Any]:
+    with open(config_file(*paths), 'r') as f:
+        return rtoml.load(f)
+
+@dataclass
+class DatabaseConfig:
+    connection_string: str
+    metadata: str
+    type: str
+    product: str
+    
+def metadata(database:str):
+    d = load_config('database', database+'.conf')
+    return DatabaseConfig(**d)
+
+@dataclass
+class QwenConfig:
+    system: str
+    prompt: str
+    params: dict[str, Any]
+    
+    def gen_prompt(self, database:DatabaseConfig):
+        return self.prompt.format(database=database, **self.params)
+
+def qwen_config(path: Optional[str] = None):
+    if path is not None:
+        d = load_config(path)
+    else:
+        d = load_config('myqwen.conf')
+    return QwenConfig(**d)
+
+
+@dataclass
+class ApiKeyConfig:
+  dashscope_api_key: str
+  admin: bool
+  databases: list[str]
+
+def api_key(key:str):
+    d = load_config('apikeys.conf')
+    if key in d:
+        return ApiKeyConfig(**d[key])
+    else:
+        return None
+
+@dataclass
+class BizWechatConfig:
+    corp_id:str
+    corp_secret:str
+    agent_id:int
+    token:str
+    aes_key:str
+    qgi_api_key:str
+    
+@dataclass
+class AppConfig:
+    site_url:str
+    
+def app_config():
+    d = load_config('app.conf')
+    d.pop('bizwechat')
+    return AppConfig(**d)
+
+def bizwechat_config():
+    d = load_config('app.conf')
+    return BizWechatConfig(**d['bizwechat'])
+
+@dataclass
+class RefineProblemConfig:
+    prompt:str
+
+def refineProblem_config(path: Optional[str] = None):
+    if path is not None:
+        d = load_config(path)
+    else:
+        d = load_config("problem_refine.conf")
+    return RefineProblemConfig(**d)
+
+import yaml
+def model_config():
+    with open(config_file("model.yaml"), 'r') as file:
+        return yaml.safe_load(file)
+
+class WxBiz:
+    lock = Lock()
+    access_token:str = None
+    expire_time:float = 0
+
+def wxbiz_token():
+    with WxBiz.lock:
+        cfg_file = osp.join(CONFIG_DIR, 'wxbiz-access-token')
+        if WxBiz.expire_time == 0 and osp.exists(cfg_file):
+            with open(cfg_file, 'r') as f:
+                token = f.read()
+                items = token.split(':')
+                WxBiz.expire_time = float(items[0])
+                WxBiz.access_token = items[1]
+
+        if WxBiz.expire_time < time.time():
+            cfg = bizwechat_config()
+            data = requests.get(f'https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={cfg.corp_id}&corpsecret={cfg.corp_secret}').json()
+
+            # 假设返回的token数据格式如下  
+            # {  
+            #     "errcode": 0,  
+            #     "errmsg": "ok",  
+            #     "access_token": "ACCESS_TOKEN",  
+            #     "expires_in": 7200  
+            # }
+            if 'errcode' in data and data['errcode'] == 0:  
+                WxBiz.access_token = data['access_token']
+                WxBiz.expire_time = time.time() + data['expires_in'] - 60
+                with open(cfg_file, 'w') as f:  
+                    f.write(f"{WxBiz.expire_time}:{WxBiz.access_token}")
+            else:
+                raise RuntimeError("Failed to refresh token:", data)
+            
+        return WxBiz.access_token
--- a/config/development/apikeys.conf
+++ b/config/development/apikeys.conf
@ -0,0 +1,10 @@
+[ccscc]
+dashscope_api_key = "sk-6b39b56d21aa4406b0c67061f2e31e81"
+admin = false
+databases = ["students"]
+
+["YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI"] 
+dashscope_api_key = "sk-6b39b56d21aa4406b0c67061f2e31e81"
+admin = false
+databases = ["contracts"]
+
--- a/config/development/app.conf
+++ b/config/development/app.conf
@ -0,0 +1,11 @@
+# 站点配置
+site_url = "http://111.230.243.127:9000"
+
+# 企业微信接口参数
+[bizwechat]
+token = "8kUGYXi"
+aes_key = "A5RyPqAu5UYBGI4QJTqLbBVyHXvevIUsaMrhct1lpxo"
+corp_id = "wwcbc2d6338dd362d0"
+corp_secret = "8tWn0YsuOdZc3xcV4HjDy2nRZJ9i9KIGHQq4vUjwYzk"
+agent_id = 1000003
+qgi_api_key = "YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI"
--- a/config/development/database/contracts.conf
+++ b/config/development/database/contracts.conf
@ -0,0 +1,25 @@
+# 数据库配置 0910
+
+connection_string = "mysql+pymysql://root:Ccscc_2025@10.1.12.6:3306/contracts?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE `contracts` (
+`经办人` VARCHAR(30) comment '示例：中通服建设有限公司综合能源分公司-业务支撑中心-祝瑞敏', 
+`合同形式` VARCHAR(10) comment '枚举值：单项合同、订单合同、确收单合同、框架子合同、框架合同、结算单',
+`所属分公司` VARCHAR(16) comment '枚举值：一分公司、二分公司、三分公司、四分公司、五分公司、六分公司、七分公司、北京分公司、数字基建分公司、上海分公司、智网分公司、河北分公司、综合能源分公司、本部',
+`合同名称` VARCHAR(137) comment '可以提取到项目地点、时间、客户名称、专业的相关信息（示例：2019-2020年株洲政企信息化职称技术配合服务采购订单）',
+`项目来源` VARCHAR(10) comment '枚举值：招投标、委托、邀标',
+`专业` VARCHAR(40) comment '示例：系统集成-信息系统集成服务-楼宇智能化', 
+`地点` VARCHAR(35) comment '示例：中国-广东省-广州市-天河区', 
+`客商类型` VARCHAR(45) comment '示例：集团客户-建筑与房地产-建筑与房地产',
+`客户名称` VARCHAR(54) comment '示例：广州铁路公安局、中国移动通信集团安徽有限公司宣城分公司',
+`合同签订金额（人民币）` float comment '“超大项目”金额大于等于1亿，“重大项目”金额大于1000万而小于1亿，“一般项目”金额大于500万而小于1000万，“小项目”金额小于500万',
+`签订日期` date comment '以CURRENT_DATE获取的时间为准作为当前日期',  
+`合同有效期（结束）` date comment '示例：2001-01-01'
+)
+
+"""
+
--- a/config/development/database/contracts_0.conf
+++ b/config/development/database/contracts_0.conf
@ -0,0 +1,197 @@
+# 数据库配置
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@172.16.16.13:3306/contracts?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+# 数据库表字段描述
+[table_sql]
+`经办人` VARCHAR(30),
+【描述】`经办人`是指项目经理，提问 “谁的项目”、“项目经理” 等类似字眼时，通常涉及对该字段进行筛选。
+【举例】中通服建设七分公司-湖南分公司交付项目部-蔡胜华|中通服建设一分公司-河北集客项目部-常楠|...
+
+`经办单位` VARCHAR(16),
+【描述】`经办单位`是指各个分公司的下属部门，提问 “部门” 类似字眼时，通常涉及对该字段进行筛选。
+【举例】一分集客项目部|业务支撑中心|采购管理中心|网优交付项目部|...
+
+`经办日期` date,
+
+`所属分公司` VARCHAR(16),
+【描述】提问 “一分”、“北分”、“数分”、“智网”、“四分”、“七分公司”、“综合能源分公司” 等类似字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】中通服建设有限公司一分公司|中通服建设有限公司二分公司|中通服建设有限公司三分公司|中通服建设有限公司四分公司|中通服建设有限公司五分公司|中通服建设有限公司六分公司|中通服建设有限公司七分公司|中通服建设有限公司北京分公司|中通服建设有限公司数字基建分公司|中通服建设有限公司上海分公司|中通服建设有限公司智网分公司|中通服建设有限公司河北分公司|中通服建设有限公司综合能源分公司|中通服建设有限公司本部 
+
+`合同形式` VARCHAR(10), 
+【所有可能的值】单项合同|订单合同|确收单合同|框架子合同|框架合同|结算单
+
+`是否主合同` bool,
+【所有可能的值】0|1| 
+
+`合同名称` VARCHAR(137),
+【描述】`合同名称`即项目名称，从中可能提取到项目`地点`、`时间`、`客户名称`、`最终客户名称`、`专业`的相关信息。
+
+`合同编号` VARCHAR(37),
+
+`框架合同编号` VARCHAR(23),
+
+`框架合同名称` VARCHAR(85),
+
+`主合同编号` VARCHAR(25),
+
+`主合同名称` VARCHAR(103),
+
+`项目来源` VARCHAR(10),
+【描述】提问“招投标”“委托”“邀标”相关字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】招投标|委托|邀标
+
+`投标项目名称` VARCHAR(92),
+【描述】`投标项目名称`和`合同名称`描述基本一致。
+
+`编号生成时间` date,
+
+`专业` VARCHAR(40),
+【举例】系统集成-信息系统集成服务-视频监控集成|工程设计-勘察设计-其他勘查设计-其他|工程施工-设备工程-通信设备安装调试-基站|其他-其他-咨询服务|工程施工-管线工程-通信线路施工-线路|系统集成-信息系统集成服务-其他|工程施工-管线工程-通信管道施工-本地网管道|工程施工-建筑智能化-智能化及集成|工程施工-设备工程-通信设备安装调试-数据-网络交换设备|工程施工-管线工程-通信线路施工-电缆|...
+
+`地点` VARCHAR(35),
+【描述】`地点`的值只包含省市区县的内容，不会包含一些常见的地区俗称。
+【注意】涉及地区俗称时，需要分析其所在的省市区县信息进行筛选，不能用地区俗称进行筛选。如：提问“京津冀”的项目时，筛选的`地点`应该是北京、天津或河北，而不是直接筛选 “京津冀”。
+
+`是否关联交易` bool,
+【所有可能的值】0|1| 
+
+`合同类型名称` VARCHAR(29),
+【描述】`合同类型名称`通常和`专业`有关。
+【举例】市场经营收入类|系统集成服务类|工程施工类|工程设计类|工程总包收入|工程分包收入|通信网络维护类|设施管理类|国际类|国际贸易服务收入
+
+`聚焦行业` VARCHAR(19),
+
+`管理分公司` VARCHAR(16),
+
+`建议实施单位` VARCHAR(55),
+
+`项目部` VARCHAR(26),
+【描述】该字段和经办单位的意思一致。
+
+`最小经营单元` VARCHAR(17),
+【描述】`最小经营单位`结合了`所属分公司`和`项目部`的内容。
+
+`省公司统一编号` VARCHAR(31),
+
+`统一编号生成时间` date,
+
+`客户名称` VARCHAR(54),
+【举例】广州铁路公安局|广东电网有限责任公司广州供电局|广东电网有限责任公司广州供电局|中国移动通信集团安徽有限公司宣城分公司|中国移动通信集团安徽有限公司宣城分公司|中国移动通信集团安徽有限公司宣城分公司|中国电信股份有限公司合肥分公司|长沙海关技术中心|中共广东省委办公厅|南方电网数字平台科技（广东）有限公司|...
+
+`运营商` VARCHAR(10),
+【所有可能的值】中国电信|中国移动|中国联通|中国广电|中国铁塔|其他
+
+`中通服客商类型` VARCHAR(45),
+【举例】集团客户-建筑与房地产-建筑与房地产|集团客户-党政-党政管理|中国电信-主业上市-广东分公司|集团客户-中小聚类-中小企业|中国广电-中国广电网络集团-股份公司-广东省广播电视网络股份有限公司  (广东广电)|集团客户-互联网与IT传媒-互联网与IT科技|中国联通-各分公司-上海市分公司|中国电信-主业存续-广东省电信公司|中国电信-实业上市-安徽通服|中国电信-主业存续-山西分公司|...
+
+`合同签订金额（人民币）` float,
+【描述】`合同签订金额（人民币）`反映了项目的规模，提问“超大项目”“重大项目”“一般项目”“小项目”“营业额”等类似字眼时，通常涉及对该字段进行筛选。
+【注意】“超大项目”金额大于等于1亿，“重大项目”金额大于1000万而小于1亿，“一般项目”金额大于200万而小于1000万，“小项目”金额小于200万。有时需要计算的是金额的总值，有时需要计算平均值。
+
+`合同签订金额（不含税）` float,
+
+`是否垫资` bool,
+【所有可能的值】0|1| 
+
+`垫资金额（元）` float,
+
+`垫资说明` VARCHAR(491),
+
+`签订日期` date,
+【描述】提问到“近几年”“去年”“今年”“上个季度”与项目日期相关内容时，通常涉及对该字段进行筛选。
+【注意】以CURRENT_DATE获取的时间为准作为当前日期。
+
+`签署日期` date,
+
+`合同有效期（开始）` date,
+
+`合同有效期（结束）` date,
+
+`最终客户名称` VARCHAR(57),
+【描述】`最终客户名称`描述和`客户名称描述一致`。
+
+`最终中通服客商类型` VARCHAR(45),
+【描述】`最终中通服客商类型`和`中通服客商类型`描述一致。
+
+`税率` float,
+
+`是否通服内部合作` bool,
+【描述】提问“内部”“内部项目”“内部合作”“通服内部”等类似字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】0|1| 
+
+`项目组织模式` VARCHAR(13),
+【所有可能的值】非总包非全咨|总包-过程总包-PC总包|总包-过程总包-EPC总包|总包-过程总包-施工总包|总包-过程总包-DB总包|全过程咨询|非总包非全过程咨询|总包-过程总包-EP总包
+
+`合同结算金额（含税）` float,
+
+`列账收入（含税）` float,
+
+`开票金额（含税）` float,
+
+`收款金额（含税）` float,
+
+`是否业务关闭` bool,
+【所有可能的值】0|1|
+
+`业务关闭时间` date,
+
+`是否财务关闭` bool,
+【所有可能的值】0|1| 
+
+`财务关闭时间` date,
+
+`甲方订单编号` VARCHAR(256),
+
+`甲方合同编号` VARCHAR(68),
+
+`框架子合同编号` VARCHAR(106),
+
+`确收类型` VARCHAR(10),
+
+`业务拓展方式` VARCHAR(10),
+【所有可能的值】合作拓展|自主拓展|联合拓展|主业总包,通服分包|LH
+
+`主实业协同` bool,
+【所有可能的值】0|1| 
+
+`协同类型` VARCHAR(10),
+
+`主业合同金额` float,
+
+`对方联系人` VARCHAR(17),
+
+`对方联系电话` VARCHAR(18),
+
+`中标时间` date,
+
+`协同拓展的主业公司` VARCHAR(10),
+
+`主业合同额` float,
+
+`是否运营商政企` bool
+【所有可能的值】0|1| 
+)
+
+# 数据库表不同字段要求
+[field_requirement]
+- 如果要对 '经办人' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '合同名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '客户名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '最终客户名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '所属分公司' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '经办单位' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '投标项目名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 数据库中的金额单位为人民币元，输出时必须除以一万用 ROUND 函数取整，输出结果使用万元为单位，。
+- 如果要对 '专业' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- `项目来源` 指的是获取项目的途径，如 '招投标'。
+
+# 术语或缩写
+[preliminary]
+- 如 '七分' 这种名称是 '中通服建设七分公司' 或 '中通服建设有限公司七分公司' 的简称，一般使用模糊匹配，其他分公司简称，如 '一分',同理。
+- '小项目'指的是 '合同签订金额（人民币）' 低于20万元的项目。
+"""
--- a/config/development/database/contracts_1.conf
+++ b/config/development/database/contracts_1.conf
@ -0,0 +1,29 @@
+# 数据库配置 0812
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@172.16.16.13:3306/contracts?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE `contracts` (
+`经办人` VARCHAR(30) comment '示例：综合能源分公司-业务支撑中心-祝瑞敏', 
+`经办单位` VARCHAR(16) comment '示例：网优交付项目部', 
+`经办日期` date comment '示例：2001-01-01', 
+`所属分公司` VARCHAR(16) comment '枚举值：一分公司、二分公司、三分公司、四分公司、五分公司、六分公司、七分公司、北京分公司、数字基建分公司、上海分公司、智网分公司、河北分公司、综合能源分公司、本部',
+`合同名称` VARCHAR(137) comment '可以提取到项目地点、时间、客户名称、专业的相关信息（示例：2019-2020年株洲政企信息化职称技术配合服务采购订单）',
+`项目来源` VARCHAR(10) comment '枚举值：招投标、委托、邀标',
+`专业` VARCHAR(40) comment '示例：系统集成-信息系统集成服务-楼宇智能化', 
+`地点` VARCHAR(35) comment '示例：中国-广东省-广州市-天河区', 
+`合同类型名称` VARCHAR(29) comment '模糊匹配枚举值：市场经营收入类、系统集成服务类合同、工程设计类合同、通信网络维护类合同、软件开发类合同、供应链服务类合同、增值服务类合同、工程施工类合同、系统营维支撑类合同、设施管理类合同、国际类、国际贸易服务收入合同、贸易服务类合同、工程监理类合同、工程总包收入合同、工程分包收入合同',
+`聚焦行业` VARCHAR(19) comment '枚举值：其他、广电、IDC、电力、厂家、市政、交通、轨道',
+`项目部` VARCHAR(26) comment '示例：湖南分公司交付项目部', 
+`客户名称` VARCHAR(54) comment '示例：广州铁路公安局、中国移动通信集团安徽有限公司宣城分公司',
+`运营商` VARCHAR(10) comment '枚举值：中国电信、中国移动、中国联通、中国广电、中国铁塔、其他',
+`合同签订金额（人民币）` float comment '“超大项目”金额大于等于1亿，“重大项目”金额大于1000万而小于1亿，“一般项目”金额大于500万而小于1000万，“小项目”金额小于500万',
+`签订日期` date comment '以CURRENT_DATE获取的时间为准作为当前日期',  
+`业务拓展方式` VARCHAR(10) comment '枚举值：合作拓展、自主拓展、联合拓展、主业总包,通服分包、LH',
+`主实业协同` bool,
+)
+
+"""
--- a/config/development/database/contracts_2.conf
+++ b/config/development/database/contracts_2.conf
@ -0,0 +1,32 @@
+# 数据库配置 0828
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@172.16.16.13:3306/contracts?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE `contracts` (
+`经办人` VARCHAR(30) comment '示例：中通服建设有限公司综合能源分公司-业务支撑中心-祝瑞敏', 
+`经办单位` VARCHAR(16) comment '示例：网优交付项目部', 
+`经办日期` date comment '示例：2001-01-01', 
+`合同形式` VARCHAR(10) comment '枚举值：单项合同|订单合同|确收单合同|框架子合同|框架合同|结算单',
+`所属分公司` VARCHAR(16) comment '枚举值：中通服建设有限公司一分公司、中通服建设有限公司二分公司、中通服建设有限公司三分公司、中通服建设有限公司四分公司、中通服建设有限公司五分公司、中通服建设有限公司六分公司、中通服建设有限公司七分公司、北京分公司、数字基建分公司、上海分公司、智网分公司、河北分公司、综合能源分公司、本部',
+`合同名称` VARCHAR(137) comment '可以提取到项目地点、时间、客户名称、专业的相关信息（示例：2019-2020年株洲政企信息化职称技术配合服务采购订单）',
+`项目来源` VARCHAR(10) comment '枚举值：招投标、委托、邀标',
+`专业` VARCHAR(40) comment '示例：系统集成-信息系统集成服务-楼宇智能化', 
+`地点` VARCHAR(35) comment '示例：中国-广东省-广州市-天河区', 
+`合同类型名称` VARCHAR(29) comment '枚举值：市场经营收入类、系统集成服务类合同、工程设计类合同、其他、通信网络维护类合同、软件开发类合同、供应链服务类合同、增值服务类合同、工程施工类合同、系统营维支撑类合同、设施管理类合同、其他、国际类、国际贸易服务收入合同、贸易服务类合同、工程监理类合同、工程总包收入合同、工程分包收入合同',
+`聚焦行业` VARCHAR(19) comment '枚举值：其他、广电、IDC、电力、厂家、市政、交通、轨道',
+`项目部` VARCHAR(26) comment '示例：湖南分公司交付项目部', 
+`中通服客商类型` VARCHAR(45) comment '示例：集团客户-建筑与房地产-建筑与房地产',
+`客户名称` VARCHAR(54) comment '示例：广州铁路公安局、中国移动通信集团安徽有限公司宣城分公司',
+`运营商` VARCHAR(10) comment '枚举值：中国电信、中国移动、中国联通、中国广电、中国铁塔、其他',
+`合同签订金额（人民币）` float comment '“超大项目”金额大于等于1亿，“重大项目”金额大于1000万而小于1亿，“一般项目”金额大于500万而小于1000万，“小项目”金额小于500万',
+`签订日期` date comment '以CURRENT_DATE获取的时间为准作为当前日期',  
+`业务拓展方式` VARCHAR(10) comment '枚举值：合作拓展、自主拓展、联合拓展、主业总包,通服分包、LH',
+`主实业协同` bool,
+)
+
+"""
+
--- a/config/development/database/students.conf
+++ b/config/development/database/students.conf
@ -0,0 +1,36 @@
+# 数据库配置
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@mysql.local:3306/students?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE students (
+    student_id INTEGER PRIMARY KEY,
+    student_name VARCHAR(100), -- 学生姓名
+    major VARCHAR(100), -- 专业
+    year_of_enrollment INTEGER, -- 入学年份
+    student_age INTEGER -- 学生年龄
+);
+
+CREATE TABLE courses (
+    course_id INTEGER PRIMARY KEY,
+    course_name VARCHAR(100), -- 课程名称
+    credit REAL -- 学分
+);
+
+CREATE TABLE scores (
+    student_id INTEGER,
+    course_id INTEGER,
+    score INTEGER, -- 得分
+    semester VARCHAR(50), -- 学期
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+
+- 数据库中 'courses' 表中 'course_name' 字段有效值为 '计算机基础','数据结构','高等物理','线性代数','微积分','编程语言','量子力学','概率论','数据库系统','计算机网络'。
+- 数据库中 'scores' 表中 'semester' 字段有效值为 '2020年秋季', '2021年春季', '2021年秋季', '2022年春季', '2020年秋季', '2021年春季', '2021年秋季', '2022年春季', '2022年秋季', '2023年春季'。
+- 数据库中 'students' 表中 'major' 字段有效值为 '计算机科学', '物理学', '数学'。
+"""
--- a/config/development/logging.yaml
+++ b/config/development/logging.yaml
@ -0,0 +1,71 @@
+version: 1
+disable_existing_loggers: false
+formatters:
+  default:
+    (): uvicorn.logging.DefaultFormatter
+    fmt: '%(asctime)s - %(levelname)s %(message)s'
+    use_colors: null
+  access:
+    (): uvicorn.logging.AccessFormatter
+    fmt: '%(asctime)s - %(levelname)s %(client_addr)s - "%(request_line)s" %(status_code)s'
+  qa_formatter:
+    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+handlers:
+  default:
+    formatter: default
+    class: logging.StreamHandler
+    stream: 'ext://sys.stderr'
+  access:
+    formatter: access
+    class: logging.StreamHandler
+    stream: 'ext://sys.stdout'
+  sql_file:
+    class: logging.handlers.RotatingFileHandler
+    level: INFO
+    formatter: default
+    filename: ./log/sql.log
+    maxBytes: 10485760 # 10MB
+    backupCount: 50 #保留50个log文件
+    encoding: utf8
+  err_file:
+    class: logging.handlers.RotatingFileHandler
+    level: ERROR
+    formatter: default
+    filename: ./log/err.log
+    maxBytes: 10485760 # 10MB
+    backupCount: 50 #保留50个log文件
+    encoding: utf8
+  qa_handler:
+    class: logging.FileHandler
+    level: DEBUG
+    formatter: qa_formatter
+    filename: log/test.log
+    mode: a
+    encoding: utf8
+loggers:
+  root:
+    handlers:
+      - default
+      - err_file
+    level: INFO
+  uvicorn:
+    level: INFO
+  uvicorn.error:
+    level: INFO
+  uvicorn.access:
+    handlers:
+      - access
+    level: INFO
+    propagate: false
+  sqlcode:
+    level: DEBUG
+  question:
+    handlers:
+      - sql_file
+    level: INFO
+    propagate: false
+  qa_cache:
+    level: DEBUG
+    handlers: [qa_handler]
+    propagate: false
+
--- a/config/development/model.yaml
+++ b/config/development/model.yaml
@ -0,0 +1,15 @@
+models:
+  gpt-3:
+    type: openai
+    api_key: "your-openai-api-key"
+    model_name: "text-davinci-003"
+  qwen:
+    type: tongyi
+    model_name: qwen-turbo
+    api_key: sk-6b39b56d21aa4406b0c67061f2e31e81
+  # 需要开通付费
+  qianfan:
+    type: qianfan
+    model_name: SQLCoder-7B
+    ak: 
+    sk: 
--- a/config/development/myqwen.conf
+++ b/config/development/myqwen.conf
@ -0,0 +1,90 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码"
+
+# prompt 模板及参数，在模板中可以使用 {question} {database.metadata} 以及 {params.xxx} 引用参数
+prompt = """
+### 数据库结构
+
+{database.metadata}
+
+- [table_sql]标记下的是数据库表的建表语句，它告诉我们数据库有哪些字段以及这些字段的类型。
+- [field_requirement]标记下是编写SQL语句是对不同字段的要求，模型输出SQL语句时应严格遵守这些要求。
+
+### 问题
+
+根据以上建表语句，生成一个 SQL 来回答如下问题: [QUESTION]{question}[/QUESTION]
+
+### 步骤
+
+1、结合建表语句[table_sql]，分析该问题是否为一个指示了要查询某些数据库字段的 “明确提问”。如果该问题不是 “明确提问”，那么进行第二步，否则执行第三步。
+2、如果输入的问题不是 “明确提问”，那么它就是一个 “困难提问”，你需要对它进行扩充，生成一个 “明确提问”。
+3、结合建表语句，根据 “明确提问” 生成一个 SQL 语句。
+
+### 明确提问示例
+生成的 “明确提问” 格式应尽可能规范。一个 “明确问题” 通常会尽可能齐全地写明待查询的中文字段名或其相近名称，示例如下：[EXAMPLE]{example}[/EXAMPLE]。
+如果你由 “困难提问” 生成了 “明确提问”，那么输出中需要添加 “明确提问”，包含在```expanded```标记中。
+
+### 输出要求
+
+- 输出的字段名必须用中文描述。
+- 输出的 SQL 语句必须能够通过 {database.product} 验证。
+- 输出的 SQL 语句必须包含在 ```sql ``` 标记中。
+- 输出的 SQL 语句不要添加注释。
+- 输出的 SQL 语句使用反引号来引用中文字段名。
+- 输出的 SQL 语句中包含的字段名必须和上述的[table_sql]中的字段名保持一致。
+- 输出的 SQL 语句禁止使用别名。
+- 输出的 SQL 语句在 where 从句中的条件判断中的字段名应和[table_sql]中的字段名保持一致。
+
+### 输出格式
+'''expanded
+[EXPANDED]
+'''
+'''sql
+[SQL]
+'''
+[ANSWER]
+"""
+
+# params.requirements = """
+# - 生成的 “明确提问” 格式应尽可能规范。一个 “明确问题” 通常会尽可能齐全地写明待查询的中文字段名或其相近名称，示例如下：[EXAMPLE]{example}[/EXAMPLE]。
+# - 如果你由 “困难提问” 生成了 “明确提问”，那么输出中需要添加 “明确提问”，包含在```expanded```标记中。
+# """
+
+params.example = """
+示例1：
+输入：签订日期在2022年，合同名称中包含智慧城市，合同金额在300万以上的合同有哪些，列出合同名称，合同金额。
+输出：
+'''sql
+SELECT `合同名称`, `合同签订金额（人民币）` / 10000 AS 合同金额（万元）
+FROM `contracts`
+WHERE `签订日期` BETWEEN '2022-01-01' AND '2022-12-31'
+AND `合同名称` LIKE '%智慧城市%'
+AND `合同签订金额（人民币）` > 3000000;
+'''
+
+示例2：
+输入：所属分公司是七分公司，客户名称是中共广东省委办公厅的项目有哪些，列出所有信息。
+输出：
+'''sql
+SELECT *
+FROM contracts
+WHERE 
+    经办单位 LIKE '%七分公司%'
+    AND 客户名称 LIKE '%中共广东省委办公厅%';
+'''
+
+示例3：
+输入：业务拓展方式是联合拓展，所属分公司是二分公司，地点不在佛山市的项目一共有多少个。
+输出：
+'''sql
+SELECT COUNT(*)
+FROM contracts
+WHERE 
+    `业务拓展方式` = '联合拓展'
+    AND `所属分公司` LIKE '%二分公司%'
+    AND `地点` NOT LIKE '佛山%'
+'''
+"""
+
--- a/config/development/problem_refine.conf
+++ b/config/development/problem_refine.conf
@ -0,0 +1,26 @@
+prompt = """
+你是一位信息提取领域的专家，擅长从文本中识别关键词汇和概念，并结合上下文信息优化问题。
+
+工作流:
+  1. 接收用户输入的问题。
+  2. 使用自然语言处理技术提取问题中的关键词。
+  3. 分析问题上下文，理解用户意图。
+  4. 结合关键词和上下文信息，生成更明确的问题。
+
+优化后的问题格式：请从数据库表 contracts 中按照筛选条件【】查询字段【】
+
+例子：
+输入问题：所属分公司是七分公司，客户名称是中共广东省委办公厅的项目有哪些，列出所有信息
+关键词：所属分公司、七分公司、客户名称、中共广东省委办公厅
+优化后的问题：请从数据库表 contracts 中按照筛选条件 客户名称中包含“中共广东省委办公厅” 查询所有字段
+
+请结合以下与问题相关的背景知识：
+{context}
+
+输入问题：{question}
+
+输出格式如下：
+关键词：
+优化后的问题：
+"""
+
--- a/config/development/qwen.conf
+++ b/config/development/qwen.conf
@ -0,0 +1,36 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码"
+
+# prompt 模板及参数，在模板中可以使用 {question} {database.metadata} 以及 {params.xxx} 引用参数
+prompt = """
+### 数据库结构
+
+{database.metadata}
+
+
+### 问题
+
+根据以上建表语句，生成一个 SQL 来回答如下问题: [QUESTION]{question}[/QUESTION]
+
+
+### 要求
+
+- 输出的字段名必须用中文描述。
+- 输出的 SQL 语句必须能够通过 {database.product} 验证。
+- 输出的 SQL 语句必须包含在 ```sql ``` 标记中。
+- 输出的 SQL 语句不要添加注释。
+
+{requirements}
+
+### 输出格式
+'''sql
+[SQL]
+'''
+[ANSWER]
+"""
+
+params.requirements = """"
+- 简要描述你的想法
+"""
--- a/config/development/qwen_agent.conf
+++ b/config/development/qwen_agent.conf
@ -0,0 +1,54 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码,同时你是一个中英文专家，你可以理解prompt中的中英文语句"
+
+prompt = """
+你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码,同时你是一个中英文专家，你可以理解prompt中的中英文语句
+对于输出 SQL 语句有以下要求：
+- 输出的字段名必须用中文描述。
+- 输出的 SQL 语句必须能够通过 {product} 验证。
+- 输出的 SQL 语句必须包含在 ```sql ``` 标记中。
+- 默认对输出的 SQL语句使用 LIMIT 来限制行数，默认行数为20行
+-  输出的 SQL 语句在 where 从句中的条件判断中的字段名应和数据库表中的字段名保持一致。
+
+
+### 数据库结构
+以下是一些数据库信息：
+{metadata}
+
+### 步骤
+
+按照给定的格式回答以下问题。你可以使用下面这些工具：
+{tools}
+
+你需要遵循以下步骤进行思考：
+1. 首先查询数据库中有哪几个表，以及这些表的范式
+2. 根据提供的数据库信息和数据库表范式理解问题，生成相应的SQL语句
+3. 如果问题比较复杂，可以将它拆解成多步，使用多个SQL语句进行完成
+4. 在生成最终答案前，需要对 SQL 语句检验和执行来确保它是有效的答案；如果无效，则需要继续思考
+5. 最终答案中，将SQL查询的结果和SQL语句一起返回，注意返回的SQL语句要用```sql ```包围
+
+回答时需要遵循以下用---括起来的格式：
+---
+Question: 我需要回答的问题
+Thought: 回答这个上述我需要做些什么
+Action: ”{tool_names}“ 中的其中一个工具名
+Action Input: 选择工具所需要的输入
+Observation: 选择工具返回的结果
+...（这个思考/行动/行动输入/观察可以重复N次）
+Thought: 我现在知道最终答案
+Final Answer: 原始输入问题的最终答案，同时需要你给出解决问题的 SQL 语句，格式如下：
+```sql
+[SQL]
+```
+---
+现在开始回答，记得在给出最终答案前多按照指定格式进行一步一步的推理。
+Question: {input}
+{agent_scratchpad}
+
+"""
+
+params.example = """
+"""
+
--- a/config/development/qwen_agent_2.conf
+++ b/config/development/qwen_agent_2.conf
@ -0,0 +1,111 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码,同时你是一个中英文专家，你可以理解prompt中的中英文语句"
+
+prompt = """
+你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码,同时你是一个中英文专家，你可以理解prompt中的中英文语句
+对于输出 SQL 语句有以下要求：
+- 输出的字段名必须用中文描述。
+- 输出的 SQL 语句必须能够通过 {product} 验证。
+- 输出的 SQL 语句必须包含在 ```sql ``` 标记中。
+- 默认对输出的 SQL语句使用 LIMIT 来限制行数，默认行数为20行
+-  输出的 SQL 语句中的字段名应和数据库表中的字段名保持一致。
+
+
+### 数据库结构
+以下是一些数据库信息：
+{metadata}
+
+- [table_sql]标记下的是数据库表的建表语句，它告诉我们数据库有哪些字段以及这些字段的类型。
+
+### 步骤
+
+按照给定的格式回答以下问题。你可以使用下面这些工具：
+{tools}
+
+你需要遵循以下步骤进行思考：
+1. 首先查询数据库中有哪几个表，以及这些表的范式
+2. 根据提供的数据库信息和数据库表范式理解问题，生成相应的SQL语句
+3. 如果问题比较复杂，可以将它拆解成多步，使用多个SQL语句进行完成
+4. 在生成最终答案前，需要对 SQL 语句检验和执行来确保它是有效的答案；如果无效，则需要继续思考
+5. 最终答案中，将SQL查询的结果和SQL语句一起返回，注意返回的SQL语句要用```sql ```包围
+
+以下是一些问题的问答案例：
+{example}
+
+以下上与问题相关的上下文:
+{context}
+
+回答时需要遵循以下用---括起来的格式：
+---
+Question: 我需要回答的问题
+Refined_question: 经过大模型优化后的问题
+Thought: 回答这个上述我需要做些什么
+Action: ”{tool_names}“ 中的其中一个工具名
+Action Input: 选择工具所需要的输入
+Observation: 选择工具返回的结果
+...（这个思考/行动/行动输入/观察可以重复N次）
+Thought: 我现在知道最终答案
+Final Answer: 原始输入问题的最终答案，同时需要你给出解决问题的 SQL 语句，格式如下：
+```sql
+SELECT [字段名]
+FROM contracts
+WHERE
+    [条件语句]
+LIMIT 20;
+```
+---
+现在开始回答，记得在给出最终答案前多按照指定格式进行一步一步的推理。
+输入的问题会经过大模型进行信息提取、优化，下面会同时给出优化后的问题，请结合原始问题和优化后问题回答。
+Question: {input}
+Refined_question: {refined_question}
+{agent_scratchpad}
+
+"""
+
+params.example = """
+- 示例1
+输入：所属分公司是七分公司，客户名称是中共广东省委办公厅的项目有哪些，列出所有信息。
+输出：
+'''sql
+SELECT *
+FROM contracts
+WHERE 
+    经办单位 LIKE '%七分公司%'
+    AND 客户名称 LIKE '%中共广东省委办公厅%'
+LIMIT 20;
+
+- 示例2
+输入：广州运维重大项目。
+输出：
+'''sql
+SELECT `合同名称`,`合同签订金额（人民币）`,`所属分公司`,`项目部`,`客户名称`,`签订时间`
+FROM contracts
+WHERE 
+    `合同名称` LIKE '%运维%'
+    AND `地点` LIKE '%广州%'
+    AND `合同签订金额（人民币）` > 3000000
+LIMIT 20;
+
+- 示例3
+输入：粤东的大项目。
+输出：
+'''sql
+SELECT *
+FROM contracts
+WHERE 
+      (`地点` LIKE '%汕头市%'
+    OR `地点` LIKE '%潮州市%'
+    OR `地点` LIKE '%梅州市%'
+    OR `地点` LIKE '%汕尾市%'
+    OR `地点` LIKE '%揭阳市%'
+    OR `合同名称` LIKE '%汕头市%'
+    OR `合同名称` LIKE '%潮州市%'
+    OR `合同名称` LIKE '%梅州市%'
+    OR `合同名称` LIKE '%汕尾市%'
+    OR `合同名称` LIKE '%揭阳市%')
+    AND `合同签订金额（人民币）` > 10000000
+LIMIT 20;
+"""
+
--- a/config/development/qwen_graph.conf
+++ b/config/development/qwen_graph.conf
@ -0,0 +1,85 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你是一位专业的数据库分析师，具有将自然语言问题转化为精确SQL查询的能力"
+
+prompt = """
+- Role: SQL转换专家
+- Background: 用户需要一个能够理解自然语言问题并将其转化为SQL查询语句的智能代理。
+- Profile: 你是一位专业的数据库分析师，具有将自然语言问题转化为精确SQL查询的能力。
+- Skills: 理解自然语言、SQL语言知识、问题解析、查询构建。
+- Goals: 设计一个智能代理，能够接收自然语言问题并生成相应的SQL查询语句。
+- Constrains:
+    1. 输出的字段名必须用中文描述。
+    2. 输出的 SQL 语句必须能够通过 {product} 验证。
+    3. 输出的 SQL 语句中的字段名应和数据库表中的字段名保持一致。
+    4. 对 `所属分公司`、`专业`、`客户名称`、`合同名称`、`经办人`、`客商类型`、`地点` 等字段进行筛选时,必须使用 LIKE 语句进行模糊匹配。
+- OutputFormat: 使用```sql```标记的SQL查询语句。
+
+- Database metedata
+{metadata}
+[table_sql]标记下的是数据库表的建表语句，它告诉我们数据库有哪些字段以及这些字段的类型。
+
+- Workflow:
+1. 首先查询数据库中有哪几个表，以及这些表的范式
+2. 根据提供的数据库信息和数据库表范式理解问题，生成相应的SQL语句
+3. 如果问题比较复杂，可以将它拆解成多步，使用多个SQL语句进行完成
+4. 在生成最终答案前，需要对 SQL 语句检验和执行来确保它是有效的答案；如果无效，则需要继续思考
+5. 最终答案中，将SQL查询的结果和SQL语句一起返回，注意返回的SQL语句要用```sql ```包围
+
+- Examples:
+{example}
+
+Final Answer: 
+- Prefix: 对问题和生成SQL语句的描述
+- Code:
+```sql
+SELECT [字段名1], [字段名2], ...
+FROM [表名]
+WHERE [条件语句]
+GROUP BY [字段名1], [字段名2], ...
+HAVING [条件语句]
+ORDER BY [字段名] ASC|DESC
+LIMIT [数量] OFFSET [偏移量];
+```
+---
+Question: 
+"""
+
+params.example = """
+- 示例1
+输入：所属分公司是七分公司，客户名称是中共广东省委办公厅的项目有哪些，列出所有信息。
+输出：我们需要从contracts表中筛选出所属分公司字段包含'七分公司'以及客户名称中包含'中共广东省委办公厅'的项目名称。
+Prefix:
+Code:
+```sql
+SELECT *
+FROM contracts
+WHERE 
+    `所属分公司` LIKE '%七分公司%'
+    AND `客户名称` LIKE '%中共广东省委办公厅%';
+```
+
+- 示例2
+输入：粤东的大项目。
+输出：
+Prefix: 粤东地区包含汕头市、潮州市、梅州市、汕尾市、揭阳市，我们需要在contracts表中筛选地点字段包含这些城市或合同名称包含这些城市的项目。
+Code:
+```sql
+SELECT *
+FROM contracts
+WHERE 
+      (`地点` LIKE '%汕头市%'
+    OR `地点` LIKE '%潮州市%'
+    OR `地点` LIKE '%梅州市%'
+    OR `地点` LIKE '%汕尾市%'
+    OR `地点` LIKE '%揭阳市%'
+    OR `合同名称` LIKE '%汕头市%'
+    OR `合同名称` LIKE '%潮州市%'
+    OR `合同名称` LIKE '%梅州市%'
+    OR `合同名称` LIKE '%汕尾市%'
+    OR `合同名称` LIKE '%揭阳市%')
+    AND `合同签订金额（人民币）` > 10000000;
+```
+"""
+
--- a/config/development/rag.txt
+++ b/config/development/rag.txt
@ -0,0 +1,457 @@
+长三角	上海市，江苏省，浙江省，安徽省
+粤东	汕头市，梅州市，汕尾市，潮州市，揭阳市
+珠三角	广州市，深圳市，珠海市，佛山市，惠州市，东莞市，中山市，江门市，肇庆市
+京津唐	北京市，天津市，河北省唐山市
+成渝经济区	四川省成都市，重庆市
+环渤海经济圈	北京市，天津市，河北省，山东省，辽宁省，山西省，内蒙古自治区
+西南	云南省，贵州省，广西壮族自治区，四川省，重庆市，西藏自治区
+华北	北京市，天津市，河北省，山西省，内蒙古自治区
+华中	河南省，湖北省，湖南省
+华东	上海市，江苏省，浙江省，安徽省，福建省，江西省，山东省
+华南	广东省，广西壮族自治区，海南省
+西北	陕西省，甘肃省，青海省，宁夏回族自治区，新疆维吾尔自治区
+东北	黑龙江省，吉林省，辽宁省
+胶东半岛	山东省青岛市，烟台市，威海市，潍坊市，日照市
+苏锡常	江苏省苏州市，无锡市，常州市
+闽南金三角	福建省厦门市，泉州市，漳州市
+赣鄱平原	江西省南昌市，九江市，上饶市，抚州市，景德镇市，鹰潭市
+鲁西平原	山东省德州市，聊城市，菏泽市，济宁市，滨州市
+豫东平原	河南省商丘市，周口市，开封市，许昌市，漯河市
+湘中	湖南省长沙市，株洲市，湘潭市，娄底市，邵阳市
+鄂西生态文化旅游圈	湖北省恩施土家族苗族自治州，宜昌市，荆门市，荆州市
+陕北	陕西省榆林市，延安市
+关中	陕西省西安市，宝鸡市，咸阳市，渭南市，铜川市
+晋东南	山西省长治市，晋城市
+冀北山区	河北省张家口市，承德市
+辽东半岛	辽宁省大连市，丹东市，营口市，鞍山市，盘锦市
+吉黑沿边	吉林省延边朝鲜族自治州，黑龙江省牡丹江市，佳木斯市，双鸭山市，鸡西市，鹤岗市，伊春市，七台河市，绥化市，黑河市，大兴安岭
+珠江口西岸都市圈	广东省珠海市，中山市，江门市
+粤西	广东省湛江市，茂名市，阳江市
+粤北	广东省韶关市，清远市，河源市，梅州市，潮州市，云浮市
+浙东	浙江省宁波市，舟山市，台州市，温州市
+浙西	浙江省金华市，衢州市，丽水市
+皖南	安徽省黄山市，宣城市，池州市，芜湖市，铜陵市，马鞍山市
+皖北	安徽省亳州市，阜阳市，宿州市，淮北市，蚌埠市，淮南市
+闽东北	福建省福州市，宁德市，莆田市
+赣南	江西省赣州市
+赣南闽西革命老区	江西省赣州市，福建省龙岩市
+湘西	湖南省湘西土家族苗族自治州，张家界市，怀化市，常德市，邵阳市
+黔中	贵州省贵阳市，遵义市，安顺市，黔南布依族苗族自治州
+黔东南	贵州省黔东南苗族侗族自治州
+黔西南	贵州省黔西南布依族苗族自治州
+滇东北	云南省昭通市，曲靖市
+滇西	云南省大理白族自治州，保山市，德宏傣族景颇族自治州，临沧市，怒江傈僳族自治州，丽江市，迪庆藏族自治州
+滇南	云南省红河哈尼族彝族自治州，普洱市，西双版纳傣族自治州
+鲁南	山东省临沂市，枣庄市，济宁市，菏泽市，日照市
+豫南	河南省信阳市，驻马店市，南阳市
+豫北	河南省安阳市，鹤壁市，新乡市，焦作市，濮阳市
+豫中南	河南省许昌市，漯河市，平顶山市，周口市，商丘市
+晋北	山西省大同市，朔州市，忻州市
+晋中	山西省太原市，晋中市，吕梁市
+蒙东	内蒙古自治区赤峰市，通辽市，兴安盟，呼伦贝尔市，锡林郭勒盟东部
+蒙西	内蒙古自治区乌海市，巴彦淖尔市，阿拉善盟，鄂尔多斯市西部
+蒙南	内蒙古自治区包头市，呼和浩特市，乌兰察布市
+蒙北	内蒙古自治区呼伦贝尔市北部，锡林郭勒盟北部
+陇东	甘肃省庆阳市，平凉市
+陇南	甘肃省陇南市，天水市南部
+陇西	甘肃省定西市，天水市中部，平凉市南部
+陇北	甘肃省白银市，武威市，张掖市，酒泉市，嘉峪关市
+陇中	甘肃省兰州市，定西市，临夏回族自治州
+甘南	甘肃省甘南藏族自治州
+甘东南	甘肃省陇南市，天水市，平凉市南部
+青藏高原	西藏自治区拉萨市，昌都市，山南市，日喀则市，那曲市，阿里；青海省西宁市，海东市，海南藏族自治州，海北藏族自治州，黄南藏族自治州，果洛藏族自治州，玉树藏族自治州，海西蒙古族藏族自治州
+川东北	四川省广元市，巴中市，达州市，南充市，广安市
+川西北	四川省阿坝藏族羌族自治州，甘孜藏族自治州
+川南	四川省泸州市，宜宾市，内江市，自贡市
+川西	四川省雅安市，眉山市，乐山市，成都西部
+川中	四川省遂宁市，资阳市，德阳市，成都东部
+陕南	陕西省汉中市，安康市，商洛市
+关中平原	陕西省西安市，宝鸡市，咸阳市，渭南市，铜川市
+秦巴山区	陕西省汉中市，安康市，商洛市
+宁南	宁夏回族自治区固原市，吴忠市南部
+宁北	宁夏回族自治区银川市，石嘴山市，吴忠市北部，中卫市
+宁中	宁夏回族自治区银川市，石嘴山市，吴忠市，中卫市
+新北	新疆维吾尔自治区乌鲁木齐市，昌吉回族自治州，吐鲁番市，哈密市
+新南	新疆维吾尔自治区喀什，和田，阿克苏，克孜勒苏柯尔克孜自治州
+新东	新疆维吾尔自治区伊犁哈萨克自治州，塔城，阿勒泰
+新西	新疆维吾尔自治区博尔塔拉蒙古自治州，克拉玛依市，巴音郭楞蒙古自治州
+辽西	辽宁省朝阳市，葫芦岛市，阜新市
+辽南	辽宁省大连市，营口市，鞍山市南部
+辽北	辽宁省铁岭市，抚顺市，本溪市
+辽中	辽宁省沈阳市，辽阳市，鞍山市中部，盘锦市
+吉东	吉林省吉林市，延边朝鲜族自治州，通化市
+吉南	吉林省长春市，四平市，辽源市
+吉西	吉林省松原市，白城市
+吉北	吉林省白山市
+吉中	吉林省长春市，吉林市中部
+黑南	黑龙江省哈尔滨市，大庆市，齐齐哈尔市
+黑北	黑龙江省黑河市，大兴安岭
+黑东	黑龙江省佳木斯市，双鸭山市，鹤岗市，伊春市东部
+黑西	黑龙江省齐齐哈尔市，绥化市，伊春市西部
+黑中	黑龙江省哈尔滨市，牡丹江市，佳木斯市南部
+藏东	西藏自治区昌都市，林芝市
+藏南	西藏自治区山南市，日喀则市
+藏西	西藏自治区阿里
+藏北	西藏自治区那曲市
+桂北	广西壮族自治区桂林市，柳州市，贺州市
+桂中	广西壮族自治区南宁市，来宾市，河池市
+桂南	广西壮族自治区钦州市，北海市，防城港市
+桂西	广西壮族自治区百色市，崇左市
+桂东	广西壮族自治区梧州市，贵港市，玉林市
+琼北	海南省海口市，文昌市，澄迈县，定安县，屯昌县
+琼南	海南省三亚市，陵水黎族自治县，保亭黎族苗族自治县，乐东黎族自治县，东方市
+琼东	海南省琼海市，万宁市
+琼西	海南省儋州市，临高县，昌江黎族自治县
+琼中	海南省五指山市，白沙黎族自治县，琼中黎族苗族自治县
+豫东	河南省商丘市，周口市，开封市，许昌市东部
+豫中	河南省郑州市，许昌市，漯河市，平顶山市东部，驻马店市北部
+鲁东	山东省烟台市，威海市，青岛市东部
+鲁中	山东省济南市，淄博市，莱芜区，泰安市，潍坊市中部
+鲁西	山东省聊城市，德州市，菏泽市，济宁市，滨州市
+鲁北	山东省东营市，滨州市，德州市北部，聊城市北部
+鲁西南	山东省济宁市，菏泽市，枣庄市，临沂市西部
+豫西	河南省洛阳市，三门峡市，济源市，平顶山市西部
+鲁东半岛	山东省烟台市，威海市，青岛市东部
+胶莱平原	山东省青岛市，潍坊市，烟台市，威海市
+鲁西南平原	山东省菏泽市，济宁市，枣庄市，临沂市西部
+沂蒙山区	山东省临沂市，日照市
+淮北平原	安徽省淮北市，宿州市，亳州市，阜阳市，蚌埠市
+巢湖	安徽省合肥市，巢湖市，六安市东部
+淮河	安徽省淮南市，蚌埠市，阜阳市，亳州市，宿州市
+皖东北	安徽省宿州市，淮北市，蚌埠市北部
+赣东北	江西省上饶市，景德镇市，鹰潭市
+赣中	江西省南昌市，抚州市，吉安市
+赣西	江西省宜春市，萍乡市，新余市
+湘南	湖南省衡阳市，郴州市，永州市
+湘北	湖南省岳阳市，常德市，益阳市
+湘东	湖南省株洲市，湘潭市，长沙市东部
+京津冀	北京市，天津市，河北省
+东北三省	黑龙江省，吉林省，辽宁省
+江浙沪	江苏省，浙江省，上海市
+川渝	四川省，重庆市
+云贵川	云南省，贵州省，四川省
+两湖	湖北省，湖南省
+两广	广东省，广西壮族自治区
+陕甘宁	陕西省，甘肃省，宁夏回族自治区
+新青藏	新疆维吾尔自治区，青海省，西藏自治区
+蒙晋	内蒙古自治区，山西省
+鲁豫	山东省，河南省
+苏皖	江苏省，安徽省
+闽赣	福建省，江西省
+桂琼	广西壮族自治区，海南省
+华北平原	北京市，天津市，河北省，山西省，内蒙古自治区
+江南	上海市，江苏省南部，浙江省北部，安徽省南部，江西省东北部
+塞北	河北省北部，山西省北部，内蒙古自治区
+粤港澳大湾区	香港特别行政区、澳门特别行政区、广州市、深圳市、珠海市、佛山市、惠州市、东莞市、中山市、江门市、肇庆市
+环渤海	北京市、天津市、河北省、辽宁省、山东省
+长江中游城市群	武汉市、长沙市、南昌市、合肥市、南京市、芜湖市等
+中原城市群	郑州市、洛阳市、开封市、新乡市、焦作市等
+长江三角洲城市群	上海市、江苏省、浙江省、安徽省的主要城市
+成渝城市群	成都市、重庆市及周边城市
+长株潭城市群	长沙市、株洲市、湘潭市
+海峡西岸经济区	福州市、厦门市、泉州市、漳州市、宁德市、莆田市、三明市、龙岩市
+北部湾经济区	南宁市、北海市、钦州市、防城港市、海口市、三亚市等
+滇中城市经济圈	昆明市、曲靖市、玉溪市、楚雄彝族自治州等
+黔中城市群	贵阳市、遵义市、安顺市、六盘水市等
+陕甘宁革命老区	陕西省、甘肃省、宁夏回族自治区
+大别山革命老区	河南省信阳市、湖北省黄冈市、安徽省六安市等
+左右江革命老区	广西壮族自治区百色市、崇左市等
+太行山区	山西省长治市、晋城市、河北省石家庄市、保定市等
+武陵山区	重庆市、湖北省恩施土家族苗族自治州、湖南省湘西土家族苗族自治州等
+南岭山区	广东省韶关市、清远市、广西壮族自治区贺州市、湖南省永州市等
+川西北高原	四川省阿坝藏族羌族自治州、甘孜藏族自治州等
+黔东南苗族侗族自治州	贵州省黔东南苗族侗族自治州
+滇西北	云南省迪庆藏族自治州、怒江傈僳族自治州等
+陇南山区	甘肃省陇南市
+冀东	河北省唐山市、秦皇岛市、承德市等
+苏中	江苏省扬州市、泰州市、南通市等
+皖中	安徽省合肥市、六安市、滁州市等
+辽中南	辽宁省中部，包括沈阳市、大连市等
+苏北五市	江苏省淮安市、连云港市、宿迁市、盐城市、徐州市
+皖北六市	安徽省淮北市、亳州市、宿州市、蚌埠市、阜阳市、淮南市
+鄂西北	湖北省十堰市、襄阳市、荆门市等
+冀南	河北省邯郸市、邢台市、衡水市等
+粤西北	广东省韶关市、清远市、云浮市等
+桂东南	广西壮族自治区玉林市、贵港市、梧州市等
+海南北部	海南省海口市、文昌市、琼海市等
+海南南部	海南省三亚市、陵水黎族自治县、保亭黎族苗族自治县等
+川西南	四川省凉山彝族自治州、攀枝花市等
+黔南	贵州省黔南布依族苗族自治州
+滇东南	云南省红河哈尼族彝族自治州、文山壮族苗族自治州等
+滇西南	云南省德宏傣族景颇族自治州、西双版纳傣族自治州等
+冀中南	河北省石家庄市、邢台市、邯郸市等
+苏南	江苏省苏州市、无锡市、常州市等
+赣西北	江西省九江市、宜春市等
+鄂西南	湖北省恩施土家族苗族自治州、宜昌市等
+豫西南	河南省南阳市、信阳市、驻马店市等
+苏北	江苏省徐州市、连云港市、淮安市等
+皖中北	安徽省合肥市、蚌埠市、淮南市等
+桂西北	广西壮族自治区河池市、百色市等
+桂东北	广西壮族自治区贺州市、桂林市等
+海南中部	海南省琼中黎族苗族自治县、五指山市等
+山东半岛	山东省青岛市、烟台市、威海市等
+苏北地区	江苏省徐州市、连云港市、淮安市、宿迁市、盐城市
+鲁西北	山东省德州市、聊城市、滨州市等
+海南东部	海南省琼海市、万宁市、文昌市、三亚市等
+海南西部	海南省东方市、昌江黎族自治县、乐东黎族自治县等
+川东南	四川省泸州市、内江市、自贡市、宜宾市等
+黔北	贵州省遵义市、铜仁市等
+滇中	云南省昆明市、楚雄彝族自治州、玉溪市等
+冀西	河北省张家口市、承德市等
+鲁东南	山东省日照市、临沂市、枣庄市等
+皖东南	安徽省宣城市、黄山市、池州市、铜陵市等
+鄂东	湖北省黄冈市、鄂州市、黄石市等
+冀中	河北省石家庄市、保定市、衡水市等
+鲁中南	山东省济宁市、枣庄市、临沂市、日照市等
+鄂南	湖北省咸宁市、荆州市、宜昌市等
+海南东北部	海南省海口市、文昌市、琼海市等
+海南西北部	海南省澄迈县、临高县、儋州市等
+黔西北	贵州省毕节市、六盘水市等
+陇东南	甘肃省庆阳市、平凉市等
+晋南	山西省运城市、临汾市等
+湘西北	湖南省湘西土家族苗族自治州、张家界市等
+鄂中	湖北省随州市、荆门市、天门市等
+京津保核心区	北京市，天津市，河北省保定市
+环京津	河北省廊坊市、承德市、张家口市、秦皇岛市等
+环沪	江苏省苏州市、南通市、无锡市、常州市等
+环广深	广东省东莞市、惠州市、中山市、珠海市等
+环成都	四川省德阳市、眉山市、资阳市、绵阳市等
+环武汉	湖北省黄石市、鄂州市、孝感市、黄冈市等
+环长株潭城市群	湖南省岳阳市、益阳市、常德市、娄底市等
+环鄱阳湖经济圈	江西省九江市、上饶市、抚州市、鹰潭市等
+环杭州湾大湾区	浙江省嘉兴市、湖州市、绍兴市、宁波市等
+环太湖经济圈	江苏省苏州市、无锡市、常州市，浙江省湖州市等
+环青海湖地区	青海省海南藏族自治州、海北藏族自治州等
+环塔里木盆地	新疆维吾尔自治区阿克苏地区、喀什地区、和田地区等
+环渤海大湾区	辽宁省大连市、营口市、盘锦市、锦州市等
+环滇池地区	云南省昆明市、玉溪市、楚雄彝族自治州等
+环鄱阳湖城市群	江西省南昌市、九江市、上饶市、景德镇市等
+环洞庭湖经济圈	湖南省岳阳市、常德市、益阳市、长沙市等
+环珠江口西岸地区	广东省江门市、阳江市、茂名市、湛江市等
+环珠江口东岸地区	广东省惠州市、汕尾市、揭阳市、梅州市等
+环北部湾城市群	广西壮族自治区北海市、钦州市、防城港市等
+环巢湖	安徽省合肥市、芜湖市、马鞍山市、铜陵市等
+环太湖西部地区	江苏省常州市、无锡市、苏州市等
+环太湖东部地区	浙江省湖州市、嘉兴市等
+环巢湖城市群	安徽省合肥市、芜湖市、马鞍山市、六安市等
+环钱塘江城市群	浙江省杭州市、绍兴市、宁波市、嘉兴市等
+环太湖北部地区	江苏省泰州市、南通市等
+环巢湖经济圈	安徽省合肥市、芜湖市、马鞍山市、铜陵市等
+环鄱阳湖生态经济区	江西省南昌市、九江市、上饶市、抚州市等
+环洞庭湖生态经济区	湖南省岳阳市、常德市、益阳市、长沙市等
+环珠江口大湾区	广东省广州市、深圳市、珠海市、东莞市等
+环北部湾经济合作区	广西壮族自治区南宁市、北海市、钦州市、防城港市等
+环巢湖生态经济区	安徽省合肥市、芜湖市、马鞍山市、六安市等
+环太湖生态经济区	江苏省无锡市、苏州市、常州市，浙江省湖州市等
+环巢湖旅游区	安徽省合肥市、芜湖市、巢湖市等
+环钱塘江生态经济区	浙江省杭州市、绍兴市、宁波市、嘉兴市等
+环太湖旅游区	江苏省无锡市、苏州市、常州市，浙江省湖州市等
+环燕山	北京市，天津市，河北省承德市、秦皇岛市等
+环太行山	山西省长治市、晋城市，河北省石家庄市、邢台市等
+环大别山	河南省信阳市、南阳市，湖北省黄冈市、随州市等
+环武陵山	重庆市，湖南省湘西土家族苗族自治州，湖北省恩施土家族苗族自治州等
+环南岭	广东省韶关市、清远市，广西壮族自治区贺州市，湖南省永州市等
+环天山	新疆维吾尔自治区昌吉回族自治州、伊犁哈萨克自治州等
+环阿尔泰山	新疆维吾尔自治区阿勒泰、塔城等
+环帕米尔高原	新疆维吾尔自治区克孜勒苏柯尔克孜自治州等
+环喀喇昆仑山	新疆维吾尔自治区和田、喀什等
+环祁连山	青海省海北藏族自治州、海西蒙古族藏族自治州等
+环横断山	四川省甘孜藏族自治州、阿坝藏族羌族自治州等
+
+
+
+中通服建设有限公司有多个分公司，所属分公司包括中通服建设一分公司（简称一分）、中通服建设二分公司（二分），一直到有七分公司。
+小项目通常指的是项目金额小于20万元的项目
+
+信创    国产化替代、通用软硬件、办公系统软件开发、服务器、操作系统、数据库、中间件、应用软件、芯片、网络安全、云计算、大数据、自主可控、安全可靠、政务内网、政务外网、办公场所
+智慧	智慧城市、智慧交通、智慧医疗、智慧教育、智慧园区、智慧电力、智慧水务、智慧应急、智慧安防、智慧社区、智慧仓储、智慧工地、智慧文旅
+运维	运营维护、系统维护、设备维护、软件维护、网络维护、IT 运维、数据中心运维、云计算运维、应用运维
+系统集成	软件集成、硬件集成、网络集成、数据集成、应用集成、安全集成、系统开发、系统设计、项目管理、技术服务、解决方案
+应急	应急管理、应急救援、应急指挥、应急预案、应急物资、应急通信、应急演练、安全生产、公共安全、防灾减灾
+智慧应急建设内容	应急指挥平台、监测预警系统、风险评估、资源管理、预案管理、模拟演练、应急通信、智能救援装备 
+智慧城市建设内容	数字基础设施、运营指挥中心、智慧交通系统、智慧医疗体系、智慧教育平台、智慧园区管理、智慧政务服务、智慧安防监控、智慧能源管理、智慧环保监测、智慧水务系统、智慧社区服务
+智慧交通建设内容	智能网联、智慧停车、智慧交管、智慧交运、车路协同、交通信号控制、电子警察、测速卡口、科技治超、智能管控、交通大数据、出行服务平台
+智慧医疗建设内容	医院建筑智能化、医疗信息化、远程医疗、医疗大数据、电子病历、移动医疗、智能医疗设备、医疗影像系统、医院信息系统、医疗物联网
+智慧教育建设内容	智慧校园、智慧教室、校园物联网、教育云平台、在线教育、教学资源管理、智能教学系统、教育大数据分析、校园安全管理、智慧图书馆
+智慧园区建设内容	园区建筑智能化、基础设施、园区可视化平台、运营服务、企业应用、智能安防、能源管理、环境监测、智能停车、物业管理
+智慧电力建设内容	电力配网工程、通信网络、电力线路管线迁改、建筑智能化、应用系统开发、智慧灯杆、光伏工程、充电桩工程、无人机巡线、电力大数据
+智慧水务建设内容	城市内涝监测、雨情监测、河江湖监测、水质在线监测、智慧水厂、智慧供水、智慧排水、管网监测、水利工程信息化
+智慧安防建设内容	视频监控、门禁系统、入侵报警、人脸识别、智能分析、安防大数据、应急处置、安防小区、安防平台
+智慧社区建设内容	物业管理系统、社区服务平台、智能门禁、车辆管理、环境监测、智能家居、社区安防、养老服务、社区电商 
+智慧工地建设内容	人员管理、设备管理、环境监测、施工进度管理、质量安全管理、物料管理、远程监控、智能塔吊、BIM 技术应用 
+智慧仓储建设内容	自动化货架、智能搬运设备、仓储管理系统、库存控制、货物识别、数据分析、分拣系统、物流配送、仓库监控 
+智慧文旅建设内容	智能票务、景区导览、虚拟旅游、文化遗产数字化、游客大数据分析、文旅营销平台、智慧酒店、智慧民宿、沉浸式体验 
+
+
+数据库中有一张 contracts 表，它的字段有<`经办人`,`经办单位`,`经办日期`,`所属分公司`,`合同形式`,`是否主合同`,`合同名称`,`合同编号`,`框架合同编号`,`框架合同名称`,`主合同编号`,`主合同名称`,`项目来源`,`投标项目名称`,`编号生成时间`,`专业`,`地点`,
+`是否关联交易`,`合同类型名称`,`聚焦行业`,`管理分公司`,`建议实施单位`,`项目部`,`最小经营单元`,`省公司统一编号`,`统一编号生成时间`,`客户名称`,`运营商`,`中通服客商类型`,`合同签订金额（人民币）`,`合同签订金额（不含税）`,`是否垫资`,`垫资金额（元）`,
+`垫资说明`,`签订日期`,`签署日期`,`合同有效期（开始）`,`合同有效期（结束）`,`最终客户名称`,`最终中通服客商类型`,`税率`,`是否通服内部合作`,`项目组织模式`,`合同结算金额（含税）`,`列账收入（含税）`,`开票金额（含税）`,`收款金额（含税）`,`是否业务关闭`,
+`业务关闭时间`,`是否财务关闭`,`财务关闭时间`,`甲方订单编号`,`甲方合同编号`,`框架子合同编号`,`确收类型`,`业务拓展方式`,`主实业协同`,`协同类型`,`主业合同金额`,`对方联系人`,`对方联系电话`,`中标时间`,`协同拓展的主业公司`,`主业合同额`,`是否运营商政企`>
+
+`经办人` VARCHAR(30),
+【描述】`经办人`是指项目经理，提问 “谁的项目”、“项目经理” 等类似字眼时，通常涉及对该字段进行筛选。
+【举例】中通服建设七分公司-湖南分公司交付项目部-蔡胜华|中通服建设一分公司-河北集客项目部-常楠|...
+
+`经办单位` VARCHAR(16),
+【描述】`经办单位`是指各个分公司的下属部门，提问 “部门” 类似字眼时，通常涉及对该字段进行筛选。
+【举例】一分集客项目部|业务支撑中心|采购管理中心|网优交付项目部|...
+
+`经办日期` date,
+
+`所属分公司` VARCHAR(16),
+【描述】提问 “一分”、“北分”、“数分”、“智网”、“四分”、“七分公司”、“综合能源分公司” 等类似字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】中通服建设有限公司一分公司|中通服建设有限公司二分公司|中通服建设有限公司三分公司|中通服建设有限公司四分公司|中通服建设有限公司五分公司|中通服建设有限公司六分公司|中通服建设有限公司七分公司|中通服建设有限公司北京分公司|中通服建设有限公司数字基建分公司|中通服建设有限公司上海分公司|中通服建设有限公司智网分公司|中通服建设有限公司河北分公司|中通服建设有限公司综合能源分公司|中通服建设有限公司本部 
+
+`合同形式` VARCHAR(10), 
+【所有可能的值】单项合同|订单合同|确收单合同|框架子合同|框架合同|结算单
+
+`是否主合同` bool,
+【所有可能的值】0|1| 
+
+`合同名称` VARCHAR(137),
+【描述】`合同名称`即项目名称，从中可能提取到项目`地点`、`时间`、`客户名称`、`最终客户名称`、`专业`的相关信息。
+
+`合同编号` VARCHAR(37),
+
+`框架合同编号` VARCHAR(23),
+
+`框架合同名称` VARCHAR(85),
+
+`主合同编号` VARCHAR(25),
+
+`主合同名称` VARCHAR(103),
+
+`项目来源` VARCHAR(10),
+【描述】提问“招投标”“委托”“邀标”相关字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】招投标|委托|邀标
+
+`投标项目名称` VARCHAR(92),
+【描述】`投标项目名称`和`合同名称`描述基本一致。
+
+`编号生成时间` date,
+
+`专业` VARCHAR(40),
+【举例】系统集成-信息系统集成服务-视频监控集成|工程设计-勘察设计-其他勘查设计-其他|工程施工-设备工程-通信设备安装调试-基站|其他-其他-咨询服务|工程施工-管线工程-通信线路施工-线路|系统集成-信息系统集成服务-其他|工程施工-管线工程-通信管道施工-本地网管道|工程施工-建筑智能化-智能化及集成|工程施工-设备工程-通信设备安装调试-数据-网络交换设备|工程施工-管线工程-通信线路施工-电缆|...
+
+`地点` VARCHAR(35),
+【描述】`地点`的值只包含省市区县的内容，不会包含一些常见的地区俗称。
+【注意】涉及地区俗称时，需要分析其所在的省市区县信息进行筛选，不能用地区俗称进行筛选。如：提问“京津冀”的项目时，筛选的`地点`应该是北京、天津或河北，而不是直接筛选 “京津冀”。
+
+`是否关联交易` bool,
+【所有可能的值】0|1| 
+
+`合同类型名称` VARCHAR(29),
+【描述】`合同类型名称`通常和`专业`有关。
+【举例】市场经营收入类|系统集成服务类|工程施工类|工程设计类|工程总包收入|工程分包收入|通信网络维护类|设施管理类|国际类|国际贸易服务收入
+
+`聚焦行业` VARCHAR(19),
+
+`管理分公司` VARCHAR(16),
+
+`建议实施单位` VARCHAR(55),
+
+`项目部` VARCHAR(26),
+【描述】该字段和经办单位的意思一致。
+
+`最小经营单元` VARCHAR(17),
+【描述】`最小经营单位`结合了`所属分公司`和`项目部`的内容。
+
+`省公司统一编号` VARCHAR(31),
+
+`统一编号生成时间` date,
+
+`客户名称` VARCHAR(54),
+【举例】广州铁路公安局|广东电网有限责任公司广州供电局|广东电网有限责任公司广州供电局|中国移动通信集团安徽有限公司宣城分公司|中国移动通信集团安徽有限公司宣城分公司|中国移动通信集团安徽有限公司宣城分公司|中国电信股份有限公司合肥分公司|长沙海关技术中心|中共广东省委办公厅|南方电网数字平台科技（广东）有限公司|...
+
+`运营商` VARCHAR(10),
+【所有可能的值】中国电信|中国移动|中国联通|中国广电|中国铁塔|其他
+
+`中通服客商类型` VARCHAR(45),
+【举例】集团客户-建筑与房地产-建筑与房地产|集团客户-党政-党政管理|中国电信-主业上市-广东分公司|集团客户-中小聚类-中小企业|中国广电-中国广电网络集团-股份公司-广东省广播电视网络股份有限公司  (广东广电)|集团客户-互联网与IT传媒-互联网与IT科技|中国联通-各分公司-上海市分公司|中国电信-主业存续-广东省电信公司|中国电信-实业上市-安徽通服|中国电信-主业存续-山西分公司|...
+
+`合同签订金额（人民币）` float,
+【描述】`合同签订金额（人民币）`反映了项目的规模，提问“超大项目”“重大项目”“一般项目”“小项目”“营业额”等类似字眼时，通常涉及对该字段进行筛选。
+【注意】“超大项目”金额大于等于1亿，“重大项目”金额大于1000万而小于1亿，“一般项目”金额大于200万而小于1000万，“小项目”金额小于200万。有时需要计算的是金额的总值，有时需要计算平均值。
+
+`合同签订金额（不含税）` float,
+
+`是否垫资` bool,
+【所有可能的值】0|1| 
+
+`垫资金额（元）` float,
+
+`垫资说明` VARCHAR(491),
+
+`签订日期` date,
+【描述】提问到“近几年”“去年”“今年”“上个季度”与项目日期相关内容时，通常涉及对该字段进行筛选。
+【注意】以CURRENT_DATE获取的时间为准作为当前日期。
+
+`签署日期` date,
+
+`合同有效期（开始）` date,
+
+`合同有效期（结束）` date,
+
+`最终客户名称` VARCHAR(57),
+【描述】`最终客户名称`描述和`客户名称描述一致`。
+
+`最终中通服客商类型` VARCHAR(45),
+【描述】`最终中通服客商类型`和`中通服客商类型`描述一致。
+
+`税率` float,
+
+`是否通服内部合作` bool,
+【描述】提问“内部”“内部项目”“内部合作”“通服内部”等类似字眼时，通常涉及对该字段进行筛选。
+【所有可能的值】0|1| 
+
+`项目组织模式` VARCHAR(13),
+【所有可能的值】非总包非全咨|总包-过程总包-PC总包|总包-过程总包-EPC总包|总包-过程总包-施工总包|总包-过程总包-DB总包|全过程咨询|非总包非全过程咨询|总包-过程总包-EP总包
+
+`合同结算金额（含税）` float,
+
+`列账收入（含税）` float,
+
+`开票金额（含税）` float,
+
+`收款金额（含税）` float,
+
+`是否业务关闭` bool,
+【所有可能的值】0|1|
+
+`业务关闭时间` date,
+
+`是否财务关闭` bool,
+【所有可能的值】0|1| 
+
+`财务关闭时间` date,
+
+`甲方订单编号` VARCHAR(256),
+
+`甲方合同编号` VARCHAR(68),
+
+`框架子合同编号` VARCHAR(106),
+
+`确收类型` VARCHAR(10),
+
+`业务拓展方式` VARCHAR(10),
+【所有可能的值】合作拓展|自主拓展|联合拓展|主业总包,通服分包|LH
+
+`主实业协同` bool,
+【所有可能的值】0|1| 
+
+`协同类型` VARCHAR(10),
+
+`主业合同金额` float,
+
+`对方联系人` VARCHAR(17),
+
+`对方联系电话` VARCHAR(18),
+
+`中标时间` date,
+
+`协同拓展的主业公司` VARCHAR(10),
+
+`主业合同额` float,
+
+`是否运营商政企` bool
+【所有可能的值】0|1| 
--- a/config/production/apikeys.conf
+++ b/config/production/apikeys.conf
@ -0,0 +1,10 @@
+[ccscc]
+dashscope_api_key = "sk-6b39b56d21aa4406b0c67061f2e31e81"
+admin = false
+databases = ["students"]
+
+["YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI"] 
+dashscope_api_key = "sk-6b39b56d21aa4406b0c67061f2e31e81"
+admin = false
+databases = ["contracts"]
+
--- a/config/production/app.conf
+++ b/config/production/app.conf
@ -0,0 +1,11 @@
+# 站点配置
+site_url = "https://release.platformtest.email"
+
+# 企业微信接口参数
+[bizwechat]
+token = "8kUGYXi"
+aes_key = "A5RyPqAu5UYBGI4QJTqLbBVyHXvevIUsaMrhct1lpxo"
+corp_id = "wwcbc2d6338dd362d0"
+corp_secret = "J7fAOm4QM2HvI5rpHiKVchbcNLcKABq-T-9v1B29RWo"
+agent_id = 1000002
+qgi_api_key = "YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI"
--- a/config/production/database/contracts.conf
+++ b/config/production/database/contracts.conf
@ -0,0 +1,86 @@
+# 数据库配置
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@mysql.local:3306/contracts?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE `contracts` (
+`经办人` VARCHAR(30),
+`经办单位` VARCHAR(16),
+`经办日期` date,
+`所属分公司` VARCHAR(16),
+`合同形式` VARCHAR(10),
+`是否主合同` bool,
+`合同名称` VARCHAR(137),
+`合同编号` VARCHAR(37),
+`框架合同编号` VARCHAR(23),
+`框架合同名称` VARCHAR(85),
+`主合同编号` VARCHAR(25),
+`主合同名称` VARCHAR(103),
+`项目来源` VARCHAR(10),
+`投标项目名称` VARCHAR(92),
+`编号生成时间` date,
+`专业` VARCHAR(40),
+`地点` VARCHAR(35),
+`是否关联交易` bool,
+`合同类型名称` VARCHAR(29),
+`聚焦行业` VARCHAR(19),
+`管理分公司` VARCHAR(16),
+`建议实施单位` VARCHAR(55),
+`项目部` VARCHAR(26),
+`最小经营单元` VARCHAR(17),
+`省公司统一编号` VARCHAR(31),
+`统一编号生成时间` date,
+`客户名称` VARCHAR(54),
+`运营商` VARCHAR(10),
+`中通服客商类型` VARCHAR(45),
+`合同签订金额（人民币）` float,
+`合同签订金额（不含税）` float,
+`是否垫资` bool,
+`垫资金额（元）` float,
+`垫资说明` VARCHAR(491),
+`签订日期` date,
+`签署日期` date,
+`合同有效期（开始）` date,
+`合同有效期（结束）` date,
+`最终客户名称` VARCHAR(57),
+`最终中通服客商类型` VARCHAR(45),
+`税率` float,
+`是否通服内部合作` bool,
+`项目组织模式` VARCHAR(13),
+`合同结算金额（含税）` float,
+`列账收入（含税）` float,
+`开票金额（含税）` float,
+`收款金额（含税）` float,
+`是否业务关闭` bool,
+`业务关闭时间` date,
+`是否财务关闭` bool,
+`财务关闭时间` date,
+`甲方订单编号` VARCHAR(256),
+`甲方合同编号` VARCHAR(68),
+`框架子合同编号` VARCHAR(106),
+`确收类型` VARCHAR(10),
+`业务拓展方式` VARCHAR(10),
+`主实业协同` bool,
+`协同类型` VARCHAR(10),
+`主业合同金额` float,
+`对方联系人` VARCHAR(17),
+`对方联系电话` VARCHAR(18),
+`中标时间` date,
+`协同拓展的主业公司` VARCHAR(10),
+`主业合同额` float,
+`是否运营商政企` bool
+); --合同信息表
+
+- 如果要对 '经办人' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '合同名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '客户名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '最终客户名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '所属分公司' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '经办单位' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '投标项目名称' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 如果要对 '项目名称来源' 进行筛选，必须使用 LIKE 语句进行模糊匹配。
+- 数据库中的金额单位为人民币元，输出时必须除以一万用 ROUND 函数取整，输出结果使用万元为单位，。
+"""
--- a/config/production/database/students.conf
+++ b/config/production/database/students.conf
@ -0,0 +1,36 @@
+# 数据库配置
+
+connection_string = "mysql+pymysql://root:H1wNPOz3@mysql.local:3306/students?charset=utf8mb4"
+
+type = "MySQL"
+product = "MySQL 5.7"
+
+metadata = """
+CREATE TABLE students (
+    student_id INTEGER PRIMARY KEY,
+    student_name VARCHAR(100), -- 学生姓名
+    major VARCHAR(100), -- 专业
+    year_of_enrollment INTEGER, -- 入学年份
+    student_age INTEGER -- 学生年龄
+);
+
+CREATE TABLE courses (
+    course_id INTEGER PRIMARY KEY,
+    course_name VARCHAR(100), -- 课程名称
+    credit REAL -- 学分
+);
+
+CREATE TABLE scores (
+    student_id INTEGER,
+    course_id INTEGER,
+    score INTEGER, -- 得分
+    semester VARCHAR(50), -- 学期
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+
+- 数据库中 'courses' 表中 'course_name' 字段有效值为 '计算机基础','数据结构','高等物理','线性代数','微积分','编程语言','量子力学','概率论','数据库系统','计算机网络'。
+- 数据库中 'scores' 表中 'semester' 字段有效值为 '2020年秋季', '2021年春季', '2021年秋季', '2022年春季', '2020年秋季', '2021年春季', '2021年秋季', '2022年春季', '2022年秋季', '2023年春季'。
+- 数据库中 'students' 表中 'major' 字段有效值为 '计算机科学', '物理学', '数学'。
+"""
--- a/config/production/logging.yaml
+++ b/config/production/logging.yaml
@ -0,0 +1,58 @@
+version: 1
+disable_existing_loggers: false
+formatters:
+  default:
+    (): uvicorn.logging.DefaultFormatter
+    fmt: '%(asctime)s - %(levelname)s %(message)s'
+    use_colors: null
+  access:
+    (): uvicorn.logging.AccessFormatter
+    fmt: '%(asctime)s - %(levelname)s %(client_addr)s - "%(request_line)s" %(status_code)s'
+handlers:
+  default:
+    formatter: default
+    class: logging.StreamHandler
+    stream: 'ext://sys.stderr'
+  access:
+    formatter: access
+    class: logging.StreamHandler
+    stream: 'ext://sys.stdout'
+  sql_file:
+    class: logging.handlers.RotatingFileHandler
+    level: INFO
+    formatter: default
+    filename: ./log/sql.log
+    maxBytes: 10485760 # 10MB
+    backupCount: 50 #保留50个log文件
+    encoding: utf8
+  err_file:
+    class: logging.handlers.RotatingFileHandler
+    level: ERROR
+    formatter: default
+    filename: ./log/err.log
+    maxBytes: 10485760 # 10MB
+    backupCount: 50 #保留50个log文件
+    encoding: utf8
+loggers:
+  root:
+    handlers:
+      - default
+      - err_file
+    level: INFO
+  uvicorn:
+    level: INFO
+  uvicorn.error:
+    level: INFO
+  uvicorn.access:
+    handlers:
+      - access
+    level: INFO
+    propagate: false
+  sqlcode:
+    level: DEBUG
+  question:
+    handlers:
+      - sql_file
+    level: INFO
+    propagate: false
+
--- a/config/production/qwen.conf
+++ b/config/production/qwen.conf
@ -0,0 +1,36 @@
+# qwen 模型配置
+
+# system role prompt
+system = "你擅长编写 SQL 代码，请结合具体问题编写正确规范的 SQL 代码"
+
+# prompt 模板及参数，在模板中可以使用 {question} {database.metadata} 以及 {params.xxx} 引用参数
+prompt = """
+### 数据库结构
+
+{database.metadata}
+
+
+### 问题
+
+根据以上建表语句，生成一个 SQL 来回答如下问题: [QUESTION]{question}[/QUESTION]
+
+
+### 要求
+
+- 输出的字段名必须用中文描述。
+- 输出的 SQL 语句必须能够通过 {database.product} 验证。
+- 输出的 SQL 语句必须包含在 ```sql ``` 标记中。
+- 输出的 SQL 语句不要添加注释。
+
+{requirements}
+
+### 输出格式
+'''sql
+[SQL]
+'''
+[ANSWER]
+"""
+
+params.requirements = """"
+- 除了 SELECT 语句，不要输出任何其他内容 。
+"""
--- a/main.py
+++ b/main.py
@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+import fastapi.staticfiles
+import uvicorn.config
+from http import HTTPStatus
+import fastapi
+import logging
+import config
+
+app = fastapi.FastAPI()
+
+app.mount("/output", fastapi.staticfiles.StaticFiles(directory="output"), name="output")
+
+logger = logging.getLogger('sqlcode')
+
+logger.info('ENVIRONMENT: %s', config.ENVIRONMENT)
+logger.debug('LOG DEBUG : ON')
+
+@app.get('/health', include_in_schema=False)
+def health():
+    return fastapi.Response('OK', HTTPStatus.OK)
+
+from query import app as query_app
+app.mount('/query', query_app)
+
+from wechat import app as wechat_app
+app.mount('/wechat', wechat_app)
+
+from tgi_app import app as tgi_app
+app.mount('/tgi', tgi_app)
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=8000)
--- a/pg-data/contracts-mysql.sql
+++ b/pg-data/contracts-mysql.sql
@ -0,0 +1,67 @@
+CREATE TABLE `contracts` (
+`经办人` varchar(50),
+`经办单位` varchar(20),
+`经办日期` date,
+`所属分公司` varchar(20),
+`合同形式` varchar(10),
+`是否主合同` tinyint(1),
+`合同名称` varchar(255),
+`合同编号` varchar(50),
+`框架合同编号` varchar(50),
+`框架合同名称` varchar(100),
+`主合同编号` varchar(50),
+`主合同名称` varchar(255),
+`项目来源` varchar(10),
+`投标项目名称` varchar(255),
+`编号生成时间` date,
+`专业` varchar(50),
+`地点` varchar(50),
+`是否关联交易` tinyint(1),
+`合同类型名称` varchar(50),
+`聚焦行业` varchar(20),
+`管理分公司` varchar(50),
+`建议实施单位` varchar(100),
+`项目部` varchar(50),
+`最小经营单元` varchar(50),
+`省公司统一编号` varchar(50),
+`统一编号生成时间` date,
+`客户名称` varchar(100),
+`运营商` varchar(10),
+`中通服客商类型` varchar(50),
+`合同签订金额(人民币)` double,
+`合同签订金额（不含税）` double,
+`是否垫资` tinyint(1),
+`垫资金额(元)` double,
+`垫资说明` varchar(999),
+`签订日期` date,
+`签署日期` date,
+`合同有效期（开始）` date,
+`合同有效期（结束）` date,
+`最终客户名称` varchar(100),
+`最终中通服客商类型` varchar(50),
+`税率` double,
+`是否通服内部合作` varchar(20),
+`项目组织模式` varchar(20),
+`合同结算金额（含税）` double,
+`列账收入（含税）` double,
+`开票金额（含税）` double,
+`收款金额（含税）` double,
+`是否业务关闭` tinyint(1),
+`业务关闭时间` date,
+`是否财务关闭` tinyint(1),
+`财务关闭时间` date,
+`甲方订单编号` varchar(999),
+`甲方合同编号` varchar(100),
+`框架子合同编号` varchar(255),
+`确收类型` varchar(10),
+`业务拓展方式` varchar(10),
+`主实业协同` tinyint(1),
+`协同类型` varchar(10),
+`主业合同金额` double,
+`对方联系人` varchar(50),
+`对方联系电话` varchar(50),
+`中标时间` double,
+`协同拓展的主业公司` double,
+`主业合同额` double,
+`是否运营商政企` tinyint(1)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='合同信息表';
--- a/pg-data/contracts-pg.sql
+++ b/pg-data/contracts-pg.sql
@ -0,0 +1,68 @@
+CREATE TABLE contracts (  
+    -- id INT PRIMARY KEY, -- 合同ID，自增主键
+    handler VARCHAR(1000), -- 经办人
+    handling_unit VARCHAR(1000), -- 经办单位
+    handling_date TIMESTAMP, -- 经办日期
+    branch_company VARCHAR(1000), -- 所属分公司
+    contract_form VARCHAR(1000), -- 合同形式
+    is_main_contract BOOLEAN, -- 是否主合同
+    contract_name VARCHAR(1000), -- 合同名称
+    contract_number VARCHAR(1000), -- 合同编号
+    framework_contract_number VARCHAR(1000), -- 框架合同编号
+    framework_contract_name VARCHAR(1000), -- 框架合同名称
+    main_contract_number VARCHAR(1000), -- 主合同编号
+    main_contract_name VARCHAR(1000), -- 主合同名称
+    project_source VARCHAR(1000), -- 项目来源
+    bidding_project_name VARCHAR(1000), -- 投标项目名称
+    number_generated_time TIMESTAMP, -- 编号生成时间
+    specialty VARCHAR(1000), -- 专业
+    location VARCHAR(1000), -- 地点
+    is_related_transaction BOOLEAN, -- 是否关联交易
+    contract_type_name VARCHAR(1000), -- 合同类型名称
+    focused_industry VARCHAR(1000), -- 聚焦行业
+    management_branch VARCHAR(1000), -- 管理分公司
+    suggested_implementation_unit VARCHAR(1000), -- 建议实施单位
+    project_department VARCHAR(1000), -- 项目部
+    min_business_unit VARCHAR(1000), -- 最小经营单元
+    unified_number_province VARCHAR(1000), -- 省公司统一编号
+    unified_number_generated_time TIMESTAMP, -- 统一编号生成时间
+    customer_name VARCHAR(1000), -- 客户名称
+    operator VARCHAR(1000), -- 运营商
+    zhongtongfu_customer_type VARCHAR(1000), -- 中通服客商类型
+    contract_amount_rmb DECIMAL(15,2), -- 合同签订金额(人民币)
+    contract_amount_ex_tax DECIMAL(15,2), -- 合同签订金额（不含税）
+    is_advance_fund BOOLEAN, -- 是否垫资
+    advance_fund_amount DECIMAL(15,2), -- 垫资金额(元)
+    advance_fund_description TEXT, -- 垫资说明
+    signing_date DATE, -- 签订日期
+    execution_date DATE, -- 签署日期
+    contract_start_date DATE, -- 合同有效期（开始）
+    contract_end_date DATE, -- 合同有效期（结束）
+    final_customer_name VARCHAR(1000), -- 最终客户名称
+    final_zhongtongfu_customer_type VARCHAR(1000), -- 最终中通服客商类型
+    tax_rate DECIMAL(5,2), -- 税率
+    is_internal_cooperation BOOLEAN, -- 是否通服内部合作
+    project_organization_mode VARCHAR(1000), -- 项目组织模式
+    contract_settlement_amount_inc_tax DECIMAL(15,2), -- 合同结算金额（含税）
+    book_revenue_inc_tax DECIMAL(15,2), -- 列账收入（含税）
+    invoice_amount_inc_tax DECIMAL(15,2), -- 开票金额（含税）
+    collection_amount_inc_tax DECIMAL(15,2), -- 收款金额（含税）
+    is_business_closed BOOLEAN, -- 是否业务关闭
+    business_close_time DATE, -- 业务关闭时间
+    is_financial_closed BOOLEAN, -- 是否财务关闭
+    financial_close_time DATE, -- 财务关闭时间
+    party_a_order_number VARCHAR(1000), -- 甲方订单编号
+    party_a_contract_number VARCHAR(1000), -- 甲方合同编号
+    framework_subcontract_number VARCHAR(1000), -- 框架子合同编号
+    revenue_recognition_type VARCHAR(1000), -- 确收类型
+    business_development_method VARCHAR(1000), -- 业务拓展方式
+    main_industry_collaboration VARCHAR(1000), -- 主实业协同
+    collaboration_type VARCHAR(1000), -- 协同类型
+    main_industry_contract_amount DECIMAL(15,2), -- 主业合同金额
+    counterparty_contact VARCHAR(1000), -- 对方联系人
+    counterparty_phone VARCHAR(20), -- 对方联系电话
+    bidding_win_time DATE, -- 中标时间
+    collaborative_expansion_company VARCHAR(1000), -- 协同拓展的主业公司
+    main_industry_contract_value DECIMAL(15,2), -- 主业合同额
+    is_operator_enterprise BOOLEAN -- 是否运营商政企
+);
--- a/pg-data/contracts-struct.txt
+++ b/pg-data/contracts-struct.txt
@ -0,0 +1,66 @@
+column	dtype	value
+经办人	text	中通服建设五分公司-惠州项目部-陈思敏
+经办单位	text	惠州项目部
+经办日期	date	2020-06-29 10:38:56
+所属分公司	text	中通服建设有限公司五分公司
+合同形式	text	单项合同
+是否主合同	bool	是
+合同名称	text	远程视频会议及扩音系统项目合同
+合同编号	text	SGC-SRHT-CJ-2020-01125
+框架合同编号	text	
+框架合同名称	text	
+主合同编号	text	
+主合同名称	text	
+项目来源	text	邀标
+投标项目名称	text	远程视频会议及扩音系统项目
+编号生成时间	date	2020-06-29
+专业	text	系统集成-信息系统集成服务-视频监控集成
+地点	text	中国-广东省-惠州市-市辖区
+是否关联交易	bool	否
+合同类型名称	text	市场经营收入类-系统集成服务类合同(A-8)
+聚焦行业	text	其他
+管理分公司	text	中通服建设有限公司五分公司
+建议实施单位	text	中通服建设有限公司五分公司
+项目部	text	惠州项目部
+最小经营单元	text	五分公司-惠州项目部
+省公司统一编号	text	S4412-2020-006338
+统一编号生成时间	date	2020-06-29
+客户名称	text	惠州市建设工程质量检测中心
+运营商	text	其他
+中通服客商类型	text	集团客户-建筑与房地产-建筑与房地产
+合同签订金额(人民币)	float	259805
+合同签订金额（不含税）	float	238353.21
+是否垫资	bool	
+垫资金额(元)	float	0
+垫资说明	text	
+签订日期	date	2020-06-29
+签署日期	date	2020-06-23
+合同有效期（开始）	date	2020-06-29
+合同有效期（结束）	date	2022-07-31
+最终客户名称	text	惠州市建设工程质量检测中心
+最终中通服客商类型	text	集团客户-建筑与房地产-建筑与房地产
+税率	float	9
+是否通服内部合作	bool	否
+项目组织模式	text	非总包非全咨
+合同结算金额（含税）	float	259805
+列账收入（含税）	float	259805
+开票金额（含税）	float	
+收款金额（含税）	float	
+是否业务关闭	bool	是
+业务关闭时间	date	2020-09-27
+是否财务关闭	bool	是
+财务关闭时间	date	2020-11-18
+甲方订单编号	text	
+甲方合同编号	text	0
+框架子合同编号	text	
+确收类型	text	全额
+业务拓展方式	text	合作拓展
+主实业协同	bool	N
+协同类型	text	
+主业合同金额	float	
+对方联系人	text	朱光南
+对方联系电话	text	15220678621
+中标时间	date	
+协同拓展的主业公司	text	
+主业合同额	float	
+是否运营商政企	bool	
--- a/pg-data/student-manage.sql
+++ b/pg-data/student-manage.sql
@ -0,0 +1,66 @@
+CREATE TABLE students (
+    student_id INTEGER PRIMARY KEY,
+    student_name VARCHAR(100), -- 学生姓名
+    major VARCHAR(100), -- 专业
+    year_of_enrollment INTEGER, -- 入学年份
+    student_age INTEGER -- 学生年龄
+);
+
+CREATE TABLE courses (
+    course_id INTEGER PRIMARY KEY,
+    course_name VARCHAR(100), -- 课程名称
+    credit REAL -- 学分
+);
+
+CREATE TABLE scores (
+    student_id INTEGER,
+    course_id INTEGER,
+    score INTEGER, -- 得分
+    semester VARCHAR(50), -- 学期
+    PRIMARY KEY (student_id, course_id),
+    FOREIGN KEY (student_id) REFERENCES students(student_id),
+    FOREIGN KEY (course_id) REFERENCES courses(course_id)
+);
+
+INSERT INTO students (student_id, student_name, major, year_of_enrollment, student_age) VALUES
+(1, '张三', '计算机科学', 2020, 20),
+(2, '李四', '计算机科学', 2021, 19),
+(3, '王五', '物理学', 2020, 21),
+(4, '赵六', '数学', 2021, 19),
+(5, '周七', '计算机科学', 2022, 18),
+(6, '吴八', '物理学', 2020, 21),
+(7, '郑九', '数学', 2021, 19),
+(8, '孙十', '计算机科学', 2022, 18),
+(9, '刘十一', '物理学', 2020, 21),
+(10, '陈十二', '数学', 2021, 19);
+
+INSERT INTO courses (course_id, course_name, credit) VALUES
+(1, '计算机基础', 3),
+(2, '数据结构', 4),
+(3, '高等物理', 3),
+(4, '线性代数', 4),
+(5, '微积分', 5),
+(6, '编程语言', 4),
+(7, '量子力学', 3),
+(8, '概率论', 4),
+(9, '数据库系统', 4),
+(10, '计算机网络', 4);
+
+INSERT INTO scores (student_id, course_id, score, semester) VALUES
+(1, 1, 90, '2020年秋季'),
+(1, 2, 85, '2021年春季'),
+(2, 1, 88, '2021年秋季'),
+(2, 2, 90, '2022年春季'),
+(3, 3, 92, '2020年秋季'),
+(3, 4, 85, '2021年春季'),
+(4, 3, 88, '2021年秋季'),
+(4, 4, 86, '2022年春季'),
+(5, 1, 90, '2022年秋季'),
+(5, 2, 87, '2023年春季');
+
+
+-- students.student_id can be joined with scores.student_id
+-- courses.course_id can be joined with scores.course_id
+-- 专业名称包括 计算机科学，物理学，数学
+-- 课程包括 计算机基础，数据结构，高等物理，线性代数，微积分，编程语言，量子力学，概率论，数据库系统，计算机网络
+-- 学期包括 2020年秋季，2021年春季，2021年秋季，2022年春季，2022年秋季，2023年春季
--- a/query.py
+++ b/query.py
@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+import fastapi.staticfiles
+from http import HTTPStatus
+import fastapi
+import config
+import asyncio
+from fastapi.middleware.cors import CORSMiddleware
+
+# 设置允许的源，可以是单个源或多个源
+
+app = fastapi.FastAPI()
+
+app.mount("/output",fastapi.staticfiles.StaticFiles(directory="output"), name="output")
+
+origins = [
+    "*"
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+from sqlcode.qgi import Executor, NewFormatter
+from sqlcode.langchain_model import Generator
+from sqlcode.modelloader import ModelLoader, ModelManager
+from sqlcode.qa_cache import QACache, load_qa_pairs
+from pydantic import BaseModel
+from sqlcode.qgi import ReturnType, QueryResult
+from sqlcode.multi_agent import create_sql_graph
+
+class QueryRequest(BaseModel):
+    '''
+    * question: str 表示要查询的问题。
+    * return_type: str 表示要返回的结果类型。
+    '''
+    question: str
+    return_type: ReturnType = ReturnType.TEXT
+
+qa_dict = load_qa_pairs('log/test.log')
+qa_cache = QACache(similarity_threshold=0.999)
+qa_cache.add(qa_dict)
+
+def try_search_in_cache(question:str) -> QueryResult:
+    cached_answer = qa_cache.find_similar(question)
+    if cached_answer != None:
+        return QueryResult(status=HTTPStatus.OK, result=cached_answer, sql='', thought='从缓存得到结果', error=None)
+    else:
+        return None
+
+
+qwen_cfg = config.qwen_config("qwen_graph.conf")
+re_cfg = config.refineProblem_config()
+
+model_cfg = config.model_config()
+modelLoader = ModelLoader(model_cfg)
+modelManager = ModelManager(modelLoader)    
+
+@app.post('/{model_name}/{database}')
+async def query(model_name:str, database:str, apikey:str, req:QueryRequest) -> QueryResult:
+    '''
+    根据请求执行查询并返回查询结果。
+    
+    - :param model: str 表示要使用的大模型的名称。例如 qwen-turbo 等
+    - :param database: str 表示要查询的数据库的名称。
+    - :param req: QueryRequest 包含查询的具体问题和期望的返回类型。
+    '''
+    print('---------进入----------')
+    # 完全匹配查找缓存结果
+    searched_result = try_search_in_cache(req.question)
+    if searched_result is not None:
+        print('从缓存找到结果')
+        print(searched_result.result)
+        return searched_result
+    
+    # 调用模型生成sql和答案
+    client = config.api_key(apikey)
+    if not client:
+        return QueryResult(status=HTTPStatus.UNAUTHORIZED, error='invalid apikey')
+    
+    if not database in client.databases:
+        return QueryResult(status=HTTPStatus.FORBIDDEN, error='database permission denied')
+    
+    metadata = config.metadata(database)
+    modelManager.switch_model(model_name)
+    model = modelManager.get_model()
+    
+    agent_executor = create_sql_graph(model=model, qwen_cfg=qwen_cfg, data_cfg=metadata)
+    
+    generator = Generator(agentExcutor=agent_executor, 
+                          messages=[{'role':'system', 'content': qwen_cfg.system}], 
+                          apikey=client.dashscope_api_key,
+                          seed=0,
+                          )
+
+    input = {"messages": [("human", req.question)], "iterations": 0}
+    
+    if req.return_type == ReturnType.SQL:
+        return generator.generate(input)
+    
+    formatter = NewFormatter(format=req.return_type, 
+                             tranlate=None, 
+                             output_dir=config.osp.join(config.BASE_DIR, 'output'), 
+                             site_url=config.app_config().site_url + '/output',
+                             )
+    
+    executor = Executor(generator=generator, formatter=formatter)
+
+    query_result = executor.query(connection_string=metadata.connection_string,
+                          input=input,
+                          )
+    
+    qa_cache.add({req.question: query_result.result})
+    return query_result
+
+
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) > 1 and sys.argv[1] == 'test':
+        import logging
+        logging.basicConfig(level=logging.DEBUG)
+        ret = asyncio.run(query(apikey='ccscc', 
+                          model='qwen-max',
+                          database='students', 
+                          req=QueryRequest(
+                              question="2022年有哪几门课程", 
+                              return_type=ReturnType.TEXT
+                              ), 
+                          ))
+        print(ret)
+    else:
+        import uvicorn
+        uvicorn.run(app, host='0.0.0.0', port=9000)
--- a/requirements.txt
+++ b/requirements.txt
@ -0,0 +1,15 @@
+dashscope
+fastapi
+sqlalchemy
+tencentcloud-sdk-python
+pandas
+psycopg2-binary
+openpyxl
+tabulate
+wcwidth
+loguru
+markdown
+pycryptodome
+pymysql
+uvicorn
+rtoml
--- a/sqlcode/baidu_qianfan_endpoint.py
+++ b/sqlcode/baidu_qianfan_endpoint.py
@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import logging
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+)
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain_core.language_models.llms import LLM
+from langchain_core.outputs import GenerationChunk
+from langchain_core.pydantic_v1 import Field, SecretStr
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+
+logger = logging.getLogger(__name__)
+
+
+class QianfanLLMEndpoint(LLM):
+    """Baidu Qianfan hosted open source or customized models.
+
+    To use, you should have the ``qianfan`` python package installed, and
+    the environment variable ``qianfan_ak`` and ``qianfan_sk`` set with
+    your API key and Secret Key.
+
+    ak, sk are required parameters which you could get from
+    https://cloud.baidu.com/product/wenxinworkshop
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.llms import QianfanLLMEndpoint
+            qianfan_model = QianfanLLMEndpoint(model="ERNIE-Bot",
+                endpoint="your_endpoint", qianfan_ak="your_ak", qianfan_sk="your_sk")
+    """
+
+    init_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """init kwargs for qianfan client init, such as `query_per_second` which is 
+        associated with qianfan resource object to limit QPS"""
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """extra params for model invoke using with `do`."""
+
+    client: Any
+
+    qianfan_ak: Optional[SecretStr] = None
+    qianfan_sk: Optional[SecretStr] = None
+
+    streaming: Optional[bool] = False
+    """Whether to stream the results or not."""
+
+    model: str = "ERNIE-Bot-turbo"
+    """Model name. 
+    you could get from https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu
+    
+    preset models are mapping to an endpoint.
+    `model` will be ignored if `endpoint` is set
+    """
+
+    endpoint: Optional[str] = None
+    """Endpoint of the Qianfan LLM, required if custom model used."""
+
+    request_timeout: Optional[int] = 60
+    """request timeout for chat http requests"""
+
+    top_p: Optional[float] = 0.8
+    temperature: Optional[float] = 0.95
+    penalty_score: Optional[float] = 1
+    """Model params, only supported in ERNIE-Bot and ERNIE-Bot-turbo.
+    In the case of other model, passing these params will not affect the result.
+    """
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        values["qianfan_ak"] = convert_to_secret_str(
+            get_from_dict_or_env(
+                values,
+                "qianfan_ak",
+                "QIANFAN_AK",
+                default="",
+            )
+        )
+        values["qianfan_sk"] = convert_to_secret_str(
+            get_from_dict_or_env(
+                values,
+                "qianfan_sk",
+                "QIANFAN_SK",
+                default="",
+            )
+            )
+
+        params = {
+                **values.get("init_kwargs", {}),
+                "model": values["model"],
+        }
+        if values["qianfan_ak"].get_secret_value() != "":
+            params["ak"] = values["qianfan_ak"].get_secret_value()
+        if values["qianfan_sk"].get_secret_value() != "":
+            params["sk"] = values["qianfan_sk"].get_secret_value()
+        if values["endpoint"] is not None and values["endpoint"] != "":
+            params["endpoint"] = values["endpoint"]
+        try:
+            import qianfan
+
+            values["client"] = qianfan.Completion(**params)
+        except ImportError:
+            raise ImportError(
+                "qianfan package not found, please install it with "
+                "`pip install qianfan`"
+            )
+        return values
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        return {
+            **{"endpoint": self.endpoint, "model": self.model},
+            **super()._identifying_params,
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "baidu-qianfan-endpoint"
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling Qianfan API."""
+        normal_params = {
+            "model": self.model,
+            "endpoint": self.endpoint,
+            "stream": self.streaming,
+            "request_timeout": self.request_timeout,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "penalty_score": self.penalty_score,
+        }
+
+        return {**normal_params, **self.model_kwargs}
+
+    def _convert_prompt_msg_params(
+        self,
+        prompt: str,
+        **kwargs: Any,
+    ) -> dict:
+        if "streaming" in kwargs:
+            kwargs["stream"] = kwargs.pop("streaming")
+        return {
+            **{"prompt": prompt, "model": self.model},
+            **self._default_params,
+            **kwargs,
+        }
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Call out to an qianfan models endpoint for each generation with a prompt.
+        Args:
+            prompt: The prompt to pass into the model.
+            stop: Optional list of stop words to use when generating.
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+                response = qianfan_model.invoke("Tell me a joke.")
+        """
+        if self.streaming:
+            completion = ""
+            for chunk in self._stream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+        params["stop"] = stop
+        response_payload = self.client.do(**params)
+
+        return response_payload["result"]
+
+    async def _acall(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        if self.streaming:
+            completion = ""
+            async for chunk in self._astream(prompt, stop, run_manager, **kwargs):
+                completion += chunk.text
+            return completion
+
+        params = self._convert_prompt_msg_params(prompt, **kwargs)
+        params["stop"] = stop
+        response_payload = await self.client.ado(**params)
+
+        return response_payload["result"]
+
+    def _stream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **{**kwargs, "stream": True})
+        params["stop"] = stop
+        for res in self.client.do(**params):
+            if res:
+                chunk = GenerationChunk(text=res["result"])
+                if run_manager:
+                    run_manager.on_llm_new_token(chunk.text)
+                yield chunk
+
+    async def _astream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[GenerationChunk]:
+        params = self._convert_prompt_msg_params(prompt, **{**kwargs, "stream": True})
+        params["stop"] = stop
+        async for res in await self.client.ado(**params):
+            if res:
+                chunk = GenerationChunk(text=res["result"])
+                if run_manager:
+                    await run_manager.on_llm_new_token(chunk.text)
+                yield chunk
--- a/sqlcode/langchain_model.py
+++ b/sqlcode/langchain_model.py
@ -0,0 +1,70 @@
+'''
+Author: scutlzc scutlzc@gmail.com
+Date: 2024-07-11 16:36:34
+LastEditors: scutlzc scutlzc@gmail.com
+LastEditTime: 2024-07-12 11:03:24
+FilePath: \bizwechat\sqlcode\langchain_model.py
+Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+'''
+from dashscope import Generation
+import random
+from http import HTTPStatus
+from enum import Enum
+from .qgi import Generator as BaseGenerator
+from langchain_community.llms import Tongyi
+from langchain_core.language_models import BaseLLM
+from langchain.prompts import PromptTemplate
+from langchain.chains.llm import LLMChain
+from enum import StrEnum
+from .modelloader import ModelManager, ModelLoader
+from langchain.agents import AgentExecutor
+from langchain_core.exceptions import OutputParserException
+from sqlcode.utils import enrich_input
+from typing import Optional
+from langgraph.graph.graph import CompiledGraph
+
+class Generator(BaseGenerator):
+    def __init__(self,  agentExcutor:CompiledGraph, messages:list[dict[str,str]]|None, apikey:str, seed:int=0, max_retry: Optional[int] = 2) -> None:
+        self.message = messages
+        self.apikey = apikey
+        self.seed = seed
+        self.agentExcutor = agentExcutor
+        self.max_retry = max_retry
+        
+    def _generate(self, input: dict) -> tuple[HTTPStatus]:
+        seed = self.seed
+        if seed == 0:
+            seed = random.randint(1, 10000)
+        
+        cnt = 0
+        err = None
+        while cnt < self.max_retry:
+            try:
+                if cnt == 0:
+                    response = self.agentExcutor.invoke(input)["messages"][-1][1]
+                    res = {"input": input, "output": response, "err": None}
+                else:
+                    new_input = enrich_input("之前agent执行流程发生错误，请模型输出严格按照prompt要求", input)
+                    response = self.agentExcutor.invoke(new_input)["messages"][-1][1]
+                    res = {"input": input, "output": response, "err": err}
+                status_code = HTTPStatus.OK
+            except ConnectionError as connectionError:
+                status_code = HTTPStatus.REQUEST_TIMEOUT
+                err = str(connectionError)
+            except OutputParserException as outputException:
+                cnt+=1
+                err = str(outputException)
+                print("outputException: {}".format(outputException))
+            except KeyError as keyError:
+                cnt+=1
+                err = str(keyError)
+                print("KeyError: {}".format(keyError))
+            else:
+                break
+        
+        if cnt == self.max_retry:
+            status_code = HTTPStatus.INTERNAL_SERVER_ERROR
+            res = {"input": input, "output": "模型处理异常，建议您将问题表述更加清晰，再重新尝试", "err": err}
+        
+        return status_code, res
+    
--- a/sqlcode/modelloader.py
+++ b/sqlcode/modelloader.py
@ -0,0 +1,48 @@
+'''
+Author: scutlzc scutlzc@gmail.com
+Date: 2024-07-12 09:23:37
+LastEditors: scutlzc scutlzc@gmail.com
+LastEditTime: 2024-07-12 09:51:30
+FilePath: \bizwechat\sqlcode\modelloader.py
+Description: 
+
+Copyright (c) 2024 by ${git_name_email}, All Rights Reserved. 
+'''
+import yaml
+# from langchain.llms import OpenAI
+# from langchain.chains import LLamaChain, CustomChain
+from langchain_community.llms import Tongyi
+from langchain_community.chat_models import ChatTongyi
+from sqlcode.baidu_qianfan_endpoint import QianfanLLMEndpoint
+
+class ModelLoader:
+    def __init__(self, config):
+        # with open(config_path, 'r') as file:
+        #     self.config = yaml.safe_load(file)
+        self.config = config
+
+    def load_model(self, model_name):
+        model_config = self.config['models'][model_name]
+        model_type = model_config['type']
+        if model_type == 'tongyi':
+            # return Tongyi(dashscope_api_key=model_config['api_key'], model_name=model_config['model_name'])
+            return ChatTongyi(dashscope_api_key=model_config['api_key'], model=model_config['model_name'])
+        elif model_type == 'qianfan':
+            return QianfanLLMEndpoint(qianfan_ak=model_config['ak'], qianfan_sk=model_config['sk'], model=model_config['model_name'])
+        else:
+            raise ValueError(f"Unknown model type: {model_type}")
+
+
+class ModelManager:
+    def __init__(self, model_loader):
+        self.model_loader = model_loader
+        self.current_model = None
+
+    def switch_model(self, model_name):
+        self.current_model = self.model_loader.load_model(model_name)
+        print(f"Switched to model: {model_name}")
+
+    def get_model(self):
+        return self.current_model
+
+
--- a/sqlcode/multi_agent.py
+++ b/sqlcode/multi_agent.py
@ -0,0 +1,242 @@
+import os
+import sys
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(parent_dir)
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.language_models import BaseLanguageModel
+from langgraph.graph.graph import CompiledGraph
+from typing import TypedDict, List
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_community.utilities import SQLDatabase
+from config import DatabaseConfig, QwenConfig
+from langgraph.graph import END, START, StateGraph, MessagesState
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain.output_parsers import OutputFixingParser
+from langchain_core.messages import RemoveMessage, AnyMessage
+import json
+
+MAX_ITERATIONS = 3
+FLAG = "reflect"
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+
+    Attributes:
+        error : Binary flag for control flow to indicate whether test error was tripped
+        messages : With user question, error messages, reasoning
+        generation : Code solution
+        iterations : Number of tries
+    """
+
+    error: str
+    messages: list[AnyMessage]
+    generation: str
+    iterations: int
+    
+class code(BaseModel):
+    """SQL输出"""
+
+    prefix: str = Field(description="对问题和使用方法的描述")
+    code: str = Field(description="SQL代码")
+    
+    
+import re
+
+def extract_sql_code(text):
+    # Regular expression to match ```sql``` blocks
+    pattern = r'```sql(.*?)```'
+    
+    # Find all matches and extract the SQL code
+    matches = re.findall(pattern, text, re.DOTALL)
+    
+    # Strip leading and trailing whitespace from each match
+    sql_code_blocks = [match.strip() for match in matches]
+    
+    return sql_code_blocks
+
+def parse_output(message):
+    content = message.content
+    sql_codes = extract_sql_code(content)
+    if len(sql_codes) > 0:
+        sql_code = sql_codes[0]
+    else:
+        sql_code = ""
+    return code(prefix=content, code=sql_code)
+    
+def truncate_strings_from_end(string_list, max_length=6000):
+    current_length = 0
+    truncated_list = []
+
+    # 从列表末尾开始遍历
+    for s in reversed(string_list):
+        if current_length + len(s) > max_length:
+            # 如果加上当前字符串长度后超过了max_length，计算可以保留的部分
+            truncated_length = max_length - current_length
+            truncated_list.append(s[-truncated_length:])
+            break
+        else:
+            truncated_list.append(s)
+            current_length += len(s)
+
+    # 由于是从后往前添加的，最后需要逆序返回
+    return list(reversed(truncated_list))
+
+def create_sql_graph(model:BaseLanguageModel, qwen_cfg: QwenConfig, data_cfg: DatabaseConfig) -> CompiledGraph:
+    # parser = PydanticOutputParser(pydantic_object=code)
+    
+    sql_gen_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", qwen_cfg.prompt),
+            # ("human", "回答用户问题，并用`json`标签包装输出 {format_instructions}"),
+            ("placeholder", "{messages}")
+        ]
+    )
+    sql_gen_prompt = sql_gen_prompt.partial(metadata=data_cfg.metadata, product=data_cfg.product, example=qwen_cfg.params["example"])
+    
+    sql_gen_chain = sql_gen_prompt | model | parse_output
+    # 生成SQL语句
+    def generate(state: GraphState):
+        messages = state["messages"]
+        iterations = state["iterations"]
+        if "error" in state:
+            error = state["error"]
+        else:
+            error = "no"
+        # error = state["error"]
+        if error == 'yes':
+            messages += [("human", "请重新生成SQL，使用 code 工具确保输出内容格式化，包括前缀（prefix）、sql代码（code）:")]
+
+        try:
+            sql_solution = sql_gen_chain.invoke({"messages": messages})
+        except ValueError as e:
+            messages = truncate_strings_from_end(messages)
+            sql_solution = sql_gen_chain.invoke({"messages": messages})
+            
+        messages += [
+            (
+                "ai",
+                f"{sql_solution.prefix} \n Code: {sql_solution.code}"
+            )
+        ]
+        iterations = iterations + 1
+        return {"generation": sql_solution, "messages": messages, "iterations": iterations}
+    # 检查SQL是否合法
+    def sql_check(state: GraphState):
+        print("---检查SQL---")
+        messages = state["messages"]
+        sql_solution = state["generation"]
+        iterations = state["iterations"]
+        
+        code = sql_solution.code
+        sql_executor = SQLDatabase.from_uri(data_cfg.connection_string)
+        
+        try:
+            sql_executor.run(code)
+        except Exception as e:
+            print("---SQL检查错误---")
+            error_msg = [("human", f"生成的SQL代码无法通过执行测试: {e}")]
+            messages += error_msg
+            return {
+                "generation": sql_solution,
+                "messages": messages,
+                "iterations": iterations,
+                "error": "yes",
+            }
+            
+        print("---SQL检测通过---")
+        return {
+            "generation": sql_solution,
+            "messages": messages,
+            "iterations": iterations,
+            "error": "no",
+        }
+    #   SQL若错误，反思
+    def reflect(state: GraphState):
+        messages = state["messages"]
+        iterations = state["iterations"]
+        sql_solution = state["generation"]
+
+        try:
+            reflections = sql_gen_chain.invoke({"messages": messages}).prefix
+        except ValueError as e:
+            messages = truncate_strings_from_end(messages)
+            reflections = sql_gen_chain.invoke({"messages": messages}).prefix
+            
+        messages += [("ai", f"这里是对于错误的反思：{reflections}")]
+        return {
+            "generation": sql_solution,
+            "messages": messages,
+            "iterations": iterations,
+            "error": "no",
+        }
+    #   删除消息，保持消息列表的长度不超过3条
+    def delete_messages(state: GraphState):
+        messages = state["messages"]
+        if len(messages) > 3:
+            new_messages = messages[-3:]
+            state["messages"] = new_messages
+        return state
+        
+    #    根据错误状态和迭代次数决定是否结束工作流
+    def decide_to_finish(state: GraphState):
+        error = state["error"]
+        iterations = state["iterations"]
+
+        if error == "no" or iterations == MAX_ITERATIONS:
+            print("---DECISION: FINISH---")
+            return "end"
+        else:
+            print("---DECISION: RE-TRY SOLUTION---")
+            if FLAG == "reflect":
+                return "reflect"
+            else:
+                return "generate"
+            
+    # 状态图
+    workflow = StateGraph(GraphState)
+    
+    workflow.add_node("generate", generate)
+    workflow.add_node("check_code", sql_check)  # check code
+    workflow.add_node("reflect", reflect)  # reflect
+    workflow.add_node("delete_messages",delete_messages)
+
+    # Build graph
+    workflow.add_edge(START, "generate")
+    workflow.add_edge("generate", "delete_messages")
+    workflow.add_edge("delete_messages", "check_code")
+    workflow.add_conditional_edges(
+        "check_code",
+        decide_to_finish,
+        {
+            "end": END,
+            "reflect": "reflect",
+            "generate": "generate",
+        },
+    )
+    workflow.add_edge("reflect", "generate")
+    app = workflow.compile()
+    
+    return app
+
+
+import config
+if __name__ == '__main__':
+    # model_name = "qwen"
+    # model_cfg = config.model_config()
+    # modelLoader = ModelLoader(model_cfg)
+    # modelManager = ModelManager(modelLoader)
+    # modelManager.switch_model(model_name)
+    # model = modelManager.get_model()
+    
+    from langchain_community.chat_models import ChatTongyi
+    model = ChatTongyi(model="qwen-turbo")
+    data_cfg = config.metadata("contracts")
+    qwen_cfg = config.qwen_config("qwen_graph.conf")
+    sql_graph = create_sql_graph(model, qwen_cfg, data_cfg)
+    input =  {"messages": [("human", "教育、工业互联网、物联网相关行业的项目都有些什么，列举合同金额、项目名称、部门、签订时间、分公司")], "iterations": 0}
+    res = sql_graph.invoke(
+       input
+    )
+    print(input)
--- a/sqlcode/qa_cache.py
+++ b/sqlcode/qa_cache.py
@ -0,0 +1,114 @@
+from cachetools import LRUCache
+from sklearn.feature_extraction.text import TfidfVectorizer
+import numpy as np
+import os
+
+class QACache:
+    def __init__(self, maxsize=100, similarity_threshold=0.5):
+        self.cache = LRUCache(maxsize=maxsize)
+        self.vectorizer = TfidfVectorizer()
+        self.questions = []
+        self.question_vectors = []
+        self.similarity_threshold = similarity_threshold  # 设置相似度阈值
+    
+    def add(self, question_and_answer:dict):
+        """添加问答对到缓存"""
+        if not isinstance(question_and_answer, dict):
+            raise TypeError("Invalid input. Expected a dictionary.")
+        if question_and_answer == {}:
+            print('传入的问答对为空。')
+            return
+        # 遍历字典并添加每个键值对
+        for question, answer in question_and_answer.items():
+            is_useful_answer = self._check_answer(answer)
+            if not is_useful_answer:
+                continue
+            self.cache[question] = answer
+            self.questions.append(question)
+        # 只有在问题添加后才进行向量化
+        print("question为:", question)
+        if len(self.questions) > 0:
+            self._vectorize_questions()
+        else:
+            print('没有有效的问题添加到缓存。')
+        # self._vectorize_questions()
+        
+    def _check_answer(self, answer:str)->bool:
+        if not isinstance(answer, str) or not answer:
+            return False
+            
+        """对回答进行过滤"""
+        if answer == "没有符合条件的记录" or answer == "没有符合条件的记录\n":
+            return False
+        
+        # 目前 answer 的类型只是 Dataframe 类型的字符串，要考虑后面存储的回答是否有其他格式
+        if answer.find('varchar') != -1:
+            return False
+        str_list = answer.split('\n')
+        for key in ['经办人', '所属分公司', '合同形式', '合同名称', '项目来源', '专业', '地点', '客户名称', '客商类型', '合同签订金额（人民币）', '签订日期', '合同有效期（结束）']:
+            if key in str_list[0]:
+                return True
+        return False
+    
+    def _vectorize_questions(self):
+        """向量化所有问题"""
+        self.question_vectors = self.vectorizer.fit_transform(self.questions)
+
+    def find_similar(self, question):
+        """找到最相似的问题和答案"""
+        if len(self.questions) == 0:
+            print('未缓存问答对。')
+            return None
+        question_vector = self.vectorizer.transform([question])
+        cosine_similarities = np.dot(self.question_vectors, question_vector.T).toarray().flatten()
+        most_similar_idx = cosine_similarities.argmax()
+        similarity_score = cosine_similarities[most_similar_idx]
+        most_similar_question = self.questions[most_similar_idx]
+        print('similarity_score:{}'.format(similarity_score))
+        print('most_similar_question:{}'.format(most_similar_question))
+        # 只有当相似度超过阈值时才返回问题和答案
+        if similarity_score > self.similarity_threshold:
+            return self.cache[most_similar_question]
+        else:
+            return None
+        
+def load_qa_pairs(qa_filename:str) -> None:
+    if not os.path.exists(qa_filename):
+        file = open(qa_filename, 'w')
+        file.close()
+    qa_dict = {}
+    with open(qa_filename, 'r') as file:
+        lines = file.readlines()
+        positions = []
+        for idx, line in enumerate(lines):
+            if line.find('qa_cache') != -1:
+                positions.append(idx)
+        positions.append(len(lines))
+        chunks = []
+        for i in range(0, len(positions)-1):
+            chunk = lines[positions[i]:positions[i+1]]
+            if '[SUCCESS]' in lines[positions[i]]:
+                chunks.append(chunk)          
+        question = ''
+        answer = ''
+        for chunk in chunks:
+            question = chunk[2].strip()
+            answer = ''.join(chunk[4:])
+            # print(question, answer)
+            qa_dict[question] = answer
+    return qa_dict
+
+if __name__ == '__main__':
+    
+    qa_dict = load_qa_pairs('log/test1111.log')
+    qa_cache = QACache(similarity_threshold=1)
+    qa_cache.add(qa_dict)    
+    # 使用示例
+    # qa_cache = QACache(maxsize=10)
+    # qa_cache.add("What is machine learning?", "Machine learning is a type of artificial intelligence.")
+    # qa_cache.add("How does machine learning work?", "It uses statistical techniques to give computers the ability to learn from data.")
+
+    # 用户提问
+    user_question = "机房的项目有哪些"
+    similar_answer = qa_cache.find_similar(user_question)
+    # print(similar_answer)
--- a/sqlcode/qgi.py
+++ b/sqlcode/qgi.py
@ -0,0 +1,378 @@
+from http import HTTPStatus
+import os
+import sqlalchemy
+import pandas as pd
+from enum import StrEnum, IntEnum
+from pydantic import BaseModel, Field
+import markdown
+import logging, logging.config
+import uuid
+from typing import Callable, Any, Optional, Union
+from sqlcode.utils import enrich_input
+import yaml
+
+logger = logging.getLogger(__name__)
+qustion_logger = logging.getLogger('question')
+
+def load_logging_config(config_path) -> None:
+    with open(config_path, 'rt') as f:
+        config = yaml.safe_load(f.read())
+    logging.config.dictConfig(config)
+
+# enum for return type
+class ReturnType(StrEnum):
+    '''
+    - SQL: 返回 SQL 语句
+    - JSON: 返回 JSON 格式的数据
+    - TEXT: 返回文本格式的数据
+    - HTML: 返回 HTML 格式的数据
+    - WX_MD: 返回企业微信 Markdown 格式的数据
+    '''
+    SQL = "sql"
+    '''返回 SQL 语句'''
+    
+    JSON = "json"
+    '''返回 JSON 格式的数据'''
+    
+    TEXT = "text"
+    '''返回文本格式的数据'''
+    
+    HTML = 'html'
+    '''返回 HTML 格式的数据'''
+    
+    WX_MD = 'wx_markdown'
+    '''返回企业微信 Markdown 格式的数据'''
+
+
+class QueryResult(BaseModel):
+    status: int = Field(default=200, description='HTTP 状态码, 200 表示成功, 其他表示失败')
+    result: str | dict[str, Any] | None = Field(default=None, description='查询结果')
+    sql: str | None = Field(default=None, description='查询的 SQL 语句')
+    thought: str | None = Field(default=None, description='大模型产生的推理')
+    error: str | None = Field(default=None, description='错误信息')
+
+
+def _retrieve_sql(text) -> Union[str|QueryResult]:
+    sql = text['output']
+    if (n:=sql.find('```sql')) >= 0:
+        n += 6
+        sql = sql[n:sql.index('```', n)]
+    elif (n:=sql.find('```\n')) >= 0:
+        n += 3
+        sql = sql[n:sql.index('```', n)]
+    elif (n:=sql.find('```\r\n')) >= 0:
+        n += 3
+        sql = sql[n:sql.index('```', n)]
+    elif (n:=sql.find('```')) >= 0:
+        sql = sql[sql.index('\n', n): sql.index('```', n+3)]
+    else:
+        return QueryResult(status=HTTPStatus.FAILED_DEPENDENCY, error='从结果中无法找到有效的查询语句。', thought=text['output'])
+        
+    sql = sql.strip()
+    return sql
+
+class Generator:
+    max_retry: Optional[int] = 2
+    
+    def generate(self, input:dict) -> QueryResult:
+        '''
+        抽象生成器类
+        
+        params:
+        - prompt: 输入文本
+        returns:
+        - code: HTTP 状态码, 200 表示成功, 其他表示失败
+        - sql: 生成的 SQL 语句，如果 code 不是 200，则 sql 中可能包含错误信息
+        - text: 生成的完全文本，内容可能包含 SQL 语句，如果 code 不是 200，则 text 中可能包含错误信息
+        '''
+        cnt=0
+        sql = ""
+        while cnt < self.max_retry:
+            code, text = self._generate(input)
+
+            if code != HTTPStatus.OK:
+                return QueryResult(status=code, error=text['err'], thought=text['output'])
+            res = _retrieve_sql(text)
+            if isinstance(res, QueryResult):
+                cnt+=1
+                print("Error: 从结果中无法找到有效的查询语句, retry again...")
+                continue
+            else:
+                sql = res
+                break        
+        
+        if sql == "":
+            return QueryResult(status=HTTPStatus.FAILED_DEPENDENCY, error='从结果中无法找到有效的查询语句。', thought=text['output'])
+        
+        logger.info('[QUESTION] %s\n%s\n%s', input['messages'][0], sql, text['output'])
+        qustion_logger.info('%s\n--------\n%s\n--------------------\n', sql, text['output'])
+
+        return QueryResult(status=HTTPStatus.OK, sql=sql, thought=text['output'])
+    
+    
+    def _generate(self, input:dict) -> tuple[HTTPStatus,str]:
+        """
+        根据给定的提示生成SQL语句。
+        
+        参数:
+        - prompt: str - 提供给模型的提示，用于生成SQL语句。
+        
+        返回:
+        - HTTPStatus - 请求的状态码，200 表示成功。
+        - str - full text, 从大模型的返回的完整回复，如果 code 不是 200，则 text 中可能包含错误信息。
+          如果 code 是 200，则 text 中的 SQL 语句应包含在围栏式代码块 ```sql ``` 中。
+        """
+        raise NotImplementedError()
+
+
+class FormatSuggest(IntEnum):
+    '''
+    对结果集的格式化建议
+    '''
+    
+    NoResult = 0
+    '''没有查询结果'''
+    
+    SingleRow = 1
+    '''结果为一行'''
+    
+    SingleColumn = 2
+    '''结果为一列'''
+    
+    MultiRow = 3
+    '''结果为多行，但行数不多，建议直接列举结果'''
+    
+    ExportToExcel = 4
+    '''结果集较大，建议导出到 Excel 文件'''
+
+
+def _suggest_format(df:pd.DataFrame) -> FormatSuggest:
+        row_count = len(df.index)
+        
+        if row_count == 0:
+            return FormatSuggest.NoResult
+        elif row_count == 1:
+            return FormatSuggest.SingleRow
+        elif row_count < 20:
+            if len(df.columns) == 1:
+                return FormatSuggest.SingleColumn
+            else:
+                return FormatSuggest.MultiRow
+        else:
+            return FormatSuggest.ExportToExcel
+
+def _translate_column_names(df:pd.DataFrame, translate:Callable[[str],str]):
+    if translate is None:
+        return
+
+    # translate column names
+    col_names = df.columns.to_list()
+    zh_names = translate(' | '.join(col_names).replace('_', ' ')).split('|')
+    zh_names = list(map(lambda s: s.strip(), zh_names))
+    if len(col_names) == len(zh_names):
+        df.columns = zh_names
+    else:
+        logger.error('[TRANSLATE] count not match (%d->%d) %s %s', len(col_names), len(zh_names), col_names, zh_names)
+
+
+# pandas 数据转为 markdown表格
+def df_to_markdown(df):
+    headers = list(df.columns)
+    # 计算每列内容的总长度
+    total_length = sum(df[col].astype(str).str.len().sum() + len(col) for col in headers)
+    # 计算每列相对比例
+    proportions = [((df[col].astype(str).str.len().sum() + len(col)) / total_length) for col in headers]
+    # 假设总宽度为 100，按比例分配宽度
+    widths = [int(100 * prop) for prop in proportions]
+    # 创建 Markdown 表格的表头
+    markdown_table = "| " + " | ".join([f"{header:<{width}}" for header, width in zip(headers, widths)]) + " |\n"
+    markdown_table += "| " + " | ".join(["---" * width for width in widths]) + " |\n"
+    # 添加数据行
+    for _, row in df.iterrows():
+        markdown_table += "| " + " | ".join([f"{str(value):<{width}}" for value, width in zip(row, widths)]) + " |\n"
+    return markdown_table
+
+class Formatter:
+    '''
+    抽象格式化器类
+    '''
+    def __init__(self, tranlate) -> None:
+        self.translate = tranlate
+            
+    def format(self, df:pd.DataFrame) -> str:
+        '''
+        格式化指定的 DataFrame。
+        '''
+        raise NotImplementedError()
+
+class _JsonFormatter(Formatter):
+    def __init__(self) -> None:
+        super().__init__(tranlate=None)
+        
+    def format(self, df:pd.DataFrame):
+        return df.to_dict(orient='split', index=False)
+
+        
+class _MarkdownFormatter(Formatter):
+    def __init__(self, tranlate, output_dir:str, site_url:str) -> None:
+        super().__init__(tranlate=tranlate)
+        self.output_dir = output_dir
+        self.site_url = site_url
+    
+    def format(self, df:pd.DataFrame):
+        suggest = _suggest_format(df)
+        
+        if suggest == FormatSuggest.NoResult:
+            return '没有符合条件的记录'
+
+        _translate_column_names(df, self.translate)
+
+        if suggest == FormatSuggest.SingleRow:
+            return ', '.join([f'{k}:{v}' for k,v in df.to_dict(orient='records')[0].items()])
+        elif suggest == FormatSuggest.SingleColumn:
+            return df[df.columns[0]].str.cat(sep='\n')
+        elif suggest == FormatSuggest.MultiRow:
+            output_file = uuid.uuid4().hex + '.xlsx'
+            df.to_excel(os.path.join(self.output_dir, output_file), index=False)
+            return df_to_markdown(df.head(10)) + \
+                '\n\n查询结果已导出到Excel文件,请点击链接下载文件：{}/{}'.format(self.site_url, output_file)
+        else:
+            # TODO 测试阶段仅保存前 10 条记录
+            output_file = uuid.uuid4().hex + '.xlsx'
+            df.to_excel(os.path.join(self.output_dir, output_file), index=False)
+            return df_to_markdown(df.head(10)) + \
+                '\n\n结果记录数或信息量太多，查询结果已导出到Excel文件(测试阶段仅导出前10行),请点击链接下载文件：{}/{}'.format(self.site_url, output_file)
+
+
+
+class _HtmlFormatter(_MarkdownFormatter):
+    def __init__(self, tranlate, output_dir: str, site_url: str) -> None:
+        super().__init__(tranlate, output_dir, site_url)
+        
+    def format(self, df:pd.DataFrame):
+        answer = super().format(df)
+        return markdown.markdown(answer, extensions=['markdown.extensions.tables'])
+
+
+class _WechatFormatter(_MarkdownFormatter):
+    def __init__(self, tranlate, output_dir: str, site_url: str) -> None:
+        super().__init__(tranlate, output_dir, site_url)
+        
+    def format(self, df: pd.DataFrame):
+        suggest = _suggest_format(df)
+        
+        if suggest == FormatSuggest.NoResult:
+            return '没有符合条件的记录'
+
+        _translate_column_names(df, self.translate)
+            
+        if suggest == FormatSuggest.ExportToExcel:
+            # TODO 测试阶段仅保存前 10 条记录 
+            output_file = uuid.uuid4().hex + '.xlsx'
+            # df.head(10).to_excel(os.path.join(self.output_dir, output_file), index=False)
+            # return f'结果记录数或信息量太多，查询结果已导出到Excel文件，请<a href="{self.site_url}/{output_file}">下载查看</a> (测试阶段仅导出前10行)'+df.head(10).to_string()
+            # return df.head(10).to_html(index=False)
+            return df_to_markdown(df.head(10))
+        elif suggest == FormatSuggest.MultiRow:
+            if len(df.columns) <= 3:
+                return '\n'.join([', '.join([str(v) for v in row.values()]) for row in df.to_dict(orient='records')])
+            else:
+                return '\n'.join([', '.join([f'{k}:{v}' for k,v in row.items()]) for row in df.to_dict(orient='records')])
+        else:
+            return super().format(df)
+    
+
+def NewFormatter(format:str, tranlate:Callable[[str],str], output_dir:str, site_url:str) -> Formatter:
+    if format == ReturnType.JSON:
+        return _JsonFormatter()
+    elif format == ReturnType.TEXT:
+        return _MarkdownFormatter(tranlate, output_dir, site_url)
+    elif format == ReturnType.HTML:
+        return _HtmlFormatter(tranlate, output_dir, site_url)
+    elif format == ReturnType.WX_MD:
+        return _WechatFormatter(tranlate, output_dir, site_url)
+    else:
+        raise ValueError('不支持的格式化器类型')
+
+
+class Executor:
+    '''
+    抽象执行器类
+    
+    params:
+    - sql: SQL 语句
+    returns:
+    - code: HTTP 状态码, 200 表示成功, 其他表示失败
+    - text: 生成的完全文本，内容可能包含 SQL 语句，如果 code 不是 200，则 text 中可能包含错误信息
+    '''
+    def __init__(self, generator:Generator, formatter:Formatter, max_retry:Optional[int] = 2) -> None:
+        self.generator = generator
+        self.formatter = formatter
+        self.max_retry = max_retry
+    
+    def get_sql(self, cnt:int, input:dict) -> dict:
+        """
+        根据提供的问题生成SQL
+
+        参数:
+        - cnt (int): 重试次数。
+        - input (dict): 主要包含用户查询的问题。
+
+        返回:
+        - dict: 生成sql的返回体。
+        """
+        print('第{}次尝试'.format(cnt+1))
+        if cnt == 0:
+            ret = self.generator.generate(input)
+        else:
+            new_input = enrich_input("之前生成的SQL语句有误或查询结果为空，请重新生成一个不同的SQL语句, question:", input)
+            ret = self.generator.generate(new_input)
+        return ret
+    
+    def query(self, connection_string:str, input:dict) -> QueryResult:
+        """
+        根据提供的模型、数据库和问题生成并执行SQL查询，然后根据返回类型返回结果。
+        
+        参数:
+        - database: str - 数据库的连接字符串。
+        - prompt: str - 提示文本。
+        - question: str - 用户的查询问题。
+        - input: 问题，input = {"messages": [("human", req.question)], "iterations": 0}
+        
+        返回:
+        - status_code - HTTP状态码。
+        - result 查询结果根据return_type的不同可以是字典、字符串或DataFrame的markdown表示。
+        - sql - 生成的SQL语句。
+        - thought - 模型生成的推理
+        """
+        error: Union[Exception|str|None] = None
+        # 使用logger记录问答对
+        load_logging_config('config/development/logging.yaml')
+        qa_logger = logging.getLogger('qa_cache')
+        #数据库连接
+        sql_engine = sqlalchemy.create_engine(connection_string)
+        with sql_engine.connect() as connection:
+            cnt = 0
+            ret = None
+            while cnt < self.max_retry:
+                ret = self.get_sql(cnt, input)
+                if ret.status != HTTPStatus.OK:
+                    qa_logger.error('[FAIL] %s\n%s', input['messages'][0][1], ret.error)
+                    return ret
+                try:
+                    #查询数据
+                    result = connection.execute(sqlalchemy.text(ret.sql))
+                    df = pd.DataFrame(result, columns=result.keys())
+                    print('******************\n', df.head(30),'\n***************\n')
+                    ret.result = self.formatter.format(df)
+                    
+                    qa_logger.info('[SUCCESS] \nInput:\n%s\nResult:\n%s', input['messages'][0][1], ret.result)
+                    break
+                except Exception as e:
+                    error = e
+                    qa_logger.error('[QUERY] %s\n%s', input['messages'][0][1], error)
+                    ret.status=HTTPStatus.INTERNAL_SERVER_ERROR
+                    ret.error=str(error)
+                    print("Error: SQL执行错误，retry agin...{}".format(error))
+                cnt+=1
+            return ret
--- a/sqlcode/qwenapi.py
+++ b/sqlcode/qwenapi.py
@ -0,0 +1,57 @@
+from dashscope import Generation
+import random
+from http import HTTPStatus
+from enum import Enum
+from .qgi import Generator as BaseGenerator
+
+class Model(str, Enum):
+    # 通义千问超大规模语言模型，支持中文、英文等不同语言输入。
+    # 模型支持 8,000 tokens上下文，为了保证正常的使用和输出，API限定用户输入为 6,000 tokens。
+    QWEN_TURBO = "qwen-turbo"
+
+    # 通义千问超大规模语言模型增强版，支持中文、英文等不同语言输入。
+    # 模型支持 32,000 tokens上下文，为了保证正常的使用和输出，API限定用户输入为30,000 tokens。
+    QWEN_PLUS = "qwen-plus"
+
+    # 通义千问千亿级别超大规模语言模型，支持中文、英文等不同语言输入。
+    # 随着模型的升级，qwen-max将滚动更新升级，如果希望使用固定版本，请使用下面的历史快照版本。
+    # 当前qwen-max模型与qwen-max-0428快照版本等价，均为最新版本的qwen-max模型，也是当前通义千问2.5产品版本背后的API模型。
+    # 模型支持 8,000 tokens上下文，为了保证正常的使用和输出，API限定用户输入为 6,000 tokens。
+    QWEN_MAX = "qwen-max"
+
+    # 通义千问千亿级别超大规模语言模型，支持中文、英文等不同语言输入。
+    # 模型支持 30,000 tokens上下文，为了保证正常的使用和输出，API限定用户输入为 28,000 tokens。     
+    QWEN_MAX_LONGCONTEXT = "qwen-max-longcontext"
+
+
+class Generator(BaseGenerator):
+    def __init__(self, model:str, messages:list[dict[str,str]]|None, apikey:str, seed:int=0) -> None:
+        '''
+        参数:
+        - model: str - 使用的大模型名称，例如 qwen-turbo。
+        - messages: list[dict[str,str]] - 提供给大模型的 messages 参数
+        - apikey: str - 用于调用模型的 dashscope API密钥。
+        - seed: int - 随机种子，用于确保生成结果的可复现性，如果忽略或为0，则生成一个随机数。
+        '''
+        self.model = model
+        self.messages = messages
+        self.apikey = apikey
+        self.seed = seed
+        
+    def _generate(self, prompt:str|None) -> tuple[HTTPStatus, str]:
+        # 设置随机数种子seed，如果没有设置，则随机数种子默认为1234
+        seed = self.seed
+        if seed == 0:
+            seed = random.randint(1, 10000)
+            
+        ret = Generation.call(model=self.model,
+                            messages=self.messages,
+                            prompt=prompt,
+                            api_key=self.apikey,
+                            seed=seed,
+                            result_format='text')
+        
+        if ret.status_code != HTTPStatus.OK:
+            return ret.status_code, ret.message
+        else:
+            return ret.status_code, ret.output.text
--- a/sqlcode/sql_agent.py
+++ b/sqlcode/sql_agent.py
@ -0,0 +1,324 @@
+"""SQL agent."""
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from langchain_core.messages import AIMessage, SystemMessage
+from langchain_core.prompts import BasePromptTemplate, PromptTemplate
+from langchain_core.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    MessagesPlaceholder,
+)
+
+from langchain_community.agent_toolkits.sql.prompt import (
+    SQL_FUNCTIONS_SUFFIX,
+    SQL_PREFIX,
+)
+from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
+from langchain_community.tools.sql_database.tool import (
+    InfoSQLDatabaseTool,
+    ListSQLDatabaseTool,
+)
+
+if TYPE_CHECKING:
+    from langchain.agents.agent import AgentExecutor
+    from langchain.agents.agent_types import AgentType
+    from langchain_core.callbacks import BaseCallbackManager
+    from langchain_core.language_models import BaseLanguageModel
+    from langchain_core.tools import BaseTool
+
+    from langchain_community.utilities.sql_database import SQLDatabase
+
+
+def create_sql_agent(
+    llm: BaseLanguageModel,
+    toolkit: Optional[SQLDatabaseToolkit] = None,
+    agent_type: Optional[
+        Union[AgentType, Literal["openai-tools", "tool-calling"]]
+    ] = None,
+    callback_manager: Optional[BaseCallbackManager] = None,
+    prefix: Optional[str] = None,
+    suffix: Optional[str] = None,
+    format_instructions: Optional[str] = None,
+    input_variables: Optional[List[str]] = None,
+    top_k: int = 10,
+    max_iterations: Optional[int] = 15,
+    max_execution_time: Optional[float] = None,
+    early_stopping_method: str = "force",
+    verbose: bool = False,
+    agent_executor_kwargs: Optional[Dict[str, Any]] = None,
+    extra_tools: Sequence[BaseTool] = (),
+    *,
+    db: Optional[SQLDatabase] = None,
+    prompt: Optional[BasePromptTemplate] = None,
+    **kwargs: Any,
+) -> AgentExecutor:
+    """Construct a SQL agent from an LLM and toolkit or database.
+
+    Args:
+        llm: Language model to use for the agent. If agent_type is "tool-calling" then
+            llm is expected to support tool calling.
+        toolkit: SQLDatabaseToolkit for the agent to use. Must provide exactly one of
+            'toolkit' or 'db'. Specify 'toolkit' if you want to use a different model
+            for the agent and the toolkit.
+        agent_type: One of "tool-calling", "openai-tools", "openai-functions", or
+            "zero-shot-react-description". Defaults to "zero-shot-react-description".
+            "tool-calling" is recommended over the legacy "openai-tools" and
+            "openai-functions" types.
+        callback_manager: DEPRECATED. Pass "callbacks" key into 'agent_executor_kwargs'
+            instead to pass constructor callbacks to AgentExecutor.
+        prefix: Prompt prefix string. Must contain variables "top_k" and "dialect".
+        suffix: Prompt suffix string. Default depends on agent type.
+        format_instructions: Formatting instructions to pass to
+            ZeroShotAgent.create_prompt() when 'agent_type' is
+            "zero-shot-react-description". Otherwise ignored.
+        input_variables: DEPRECATED.
+        top_k: Number of rows to query for by default.
+        max_iterations: Passed to AgentExecutor init.
+        max_execution_time: Passed to AgentExecutor init.
+        early_stopping_method: Passed to AgentExecutor init.
+        verbose: AgentExecutor verbosity.
+        agent_executor_kwargs: Arbitrary additional AgentExecutor args.
+        extra_tools: Additional tools to give to agent on top of the ones that come with
+            SQLDatabaseToolkit.
+        db: SQLDatabase from which to create a SQLDatabaseToolkit. Toolkit is created
+            using 'db' and 'llm'. Must provide exactly one of 'db' or 'toolkit'.
+        prompt: Complete agent prompt. prompt and {prefix, suffix, format_instructions,
+            input_variables} are mutually exclusive.
+        **kwargs: Arbitrary additional Agent args.
+
+    Returns:
+        An AgentExecutor with the specified agent_type agent.
+
+    Example:
+
+        .. code-block:: python
+
+        from langchain_openai import ChatOpenAI
+        from langchain_community.agent_toolkits import create_sql_agent
+        from langchain_community.utilities import SQLDatabase
+
+        db = SQLDatabase.from_uri("sqlite:///Chinook.db")
+        llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+        agent_executor = create_sql_agent(llm, db=db, agent_type="tool-calling", verbose=True)
+
+    """  # noqa: E501
+    from langchain.agents import (
+        create_openai_functions_agent,
+        create_openai_tools_agent,
+        create_react_agent,
+        create_tool_calling_agent,
+    )
+    from langchain.agents.agent import (
+        AgentExecutor,
+        RunnableAgent,
+        RunnableMultiActionAgent,
+    )
+    from langchain.agents.agent_types import AgentType
+
+    if toolkit is None and db is None:
+        raise ValueError(
+            "Must provide exactly one of 'toolkit' or 'db'. Received neither."
+        )
+    if toolkit and db:
+        raise ValueError(
+            "Must provide exactly one of 'toolkit' or 'db'. Received both."
+        )
+
+    toolkit = toolkit or SQLDatabaseToolkit(llm=llm, db=db)  # type: ignore[arg-type]
+    agent_type = agent_type or AgentType.ZERO_SHOT_REACT_DESCRIPTION
+    tools = toolkit.get_tools() + list(extra_tools)
+    if prompt is None:
+        prefix = prefix or SQL_PREFIX
+        prefix = prefix.format(dialect=toolkit.dialect, top_k=top_k)
+    else:
+        if "top_k" in prompt.input_variables:
+            prompt = prompt.partial(top_k=str(top_k))
+        if "dialect" in prompt.input_variables:
+            prompt = prompt.partial(dialect=toolkit.dialect)
+        if any(key in prompt.input_variables for key in ["table_info", "table_names"]):
+            db_context = toolkit.get_context()
+            if "table_info" in prompt.input_variables:
+                prompt = prompt.partial(table_info=db_context["table_info"])
+                tools = [
+                    tool for tool in tools if not isinstance(tool, InfoSQLDatabaseTool)
+                ]
+            if "table_names" in prompt.input_variables:
+                prompt = prompt.partial(table_names=db_context["table_names"])
+                tools = [
+                    tool for tool in tools if not isinstance(tool, ListSQLDatabaseTool)
+                ]
+
+    if agent_type == AgentType.ZERO_SHOT_REACT_DESCRIPTION:
+        if prompt is None:
+            from langchain.agents.mrkl import prompt as react_prompt
+
+            format_instructions = (
+                format_instructions or react_prompt.FORMAT_INSTRUCTIONS
+            )
+            template = "\n\n".join(
+                [
+                    react_prompt.PREFIX,
+                    "{tools}",
+                    format_instructions,
+                    react_prompt.SUFFIX,
+                ]
+            )
+            prompt = PromptTemplate.from_template(template)
+        agent = RunnableAgent(
+            runnable=create_react_agent(llm, tools, prompt, output_parser=ReActSingleInputOutputParserWithOutMarkDown()),
+            input_keys_arg=["input"],
+            return_keys_arg=["output"],
+            **kwargs,
+        )
+
+    elif agent_type == AgentType.OPENAI_FUNCTIONS:
+        if prompt is None:
+            messages: List = [
+                SystemMessage(content=cast(str, prefix)),
+                HumanMessagePromptTemplate.from_template("{input}"),
+                AIMessage(content=suffix or SQL_FUNCTIONS_SUFFIX),
+                MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ]
+            prompt = ChatPromptTemplate.from_messages(messages)
+        agent = RunnableAgent(
+            runnable=create_openai_functions_agent(llm, tools, prompt),  # type: ignore
+            input_keys_arg=["input"],
+            return_keys_arg=["output"],
+            **kwargs,
+        )
+    elif agent_type in ("openai-tools", "tool-calling"):
+        if prompt is None:
+            messages = [
+                SystemMessage(content=cast(str, prefix)),
+                HumanMessagePromptTemplate.from_template("{input}"),
+                AIMessage(content=suffix or SQL_FUNCTIONS_SUFFIX),
+                MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ]
+            prompt = ChatPromptTemplate.from_messages(messages)
+        if agent_type == "openai-tools":
+            runnable = create_openai_tools_agent(llm, tools, prompt)  # type: ignore
+        else:
+            runnable = create_tool_calling_agent(llm, tools, prompt)  # type: ignore
+        agent = RunnableMultiActionAgent(  # type: ignore[assignment]
+            runnable=runnable,
+            input_keys_arg=["input"],
+            return_keys_arg=["output"],
+            **kwargs,
+        )
+
+    else:
+        raise ValueError(
+            f"Agent type {agent_type} not supported at the moment. Must be one of "
+            "'tool-calling', 'openai-tools', 'openai-functions', or "
+            "'zero-shot-react-description'."
+        )
+
+    return AgentExecutor(
+        name="SQL Agent Executor",
+        agent=agent,
+        tools=tools,
+        callback_manager=callback_manager,
+        verbose=verbose,
+        max_iterations=max_iterations,
+        max_execution_time=max_execution_time,
+        early_stopping_method=early_stopping_method,
+        **(agent_executor_kwargs or {}),
+    )
+
+import re
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.exceptions import OutputParserException
+
+from langchain.agents.agent import AgentOutputParser
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
+
+FINAL_ANSWER_ACTION = "Final Answer:"
+MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = (
+    "Invalid Format: Missing 'Action:' after 'Thought:"
+)
+MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = (
+    "Invalid Format: Missing 'Action Input:' after 'Action:'"
+)
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = (
+    "Parsing LLM output produced both a final answer and a parse-able action:"
+)
+class ReActSingleInputOutputParserWithOutMarkDown(AgentOutputParser):
+    def get_format_instructions(self) -> str:
+        return FORMAT_INSTRUCTIONS
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        includes_answer = FINAL_ANSWER_ACTION in text
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        )
+        print("text: {}".format(text))
+        action_match = re.search(regex, text, re.DOTALL)
+        if action_match:
+            if includes_answer:
+                raise OutputParserException(
+                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                )
+            action = action_match.group(1).strip()
+            action_input = action_match.group(2)
+            tool_input = action_input.strip(" ")
+            tool_input = tool_input.strip('"')
+            
+            # Remove markdown code block markers if present
+            tool_input = re.sub(r'(^```\s*sql\s*|^\s*```$)', '', tool_input, flags=re.MULTILINE).strip()
+            tool_input = re.sub(r'(^`\s*|`\s*$)', '', tool_input).strip()
+
+            return AgentAction(action, tool_input, text)
+
+        elif includes_answer:
+            return AgentFinish(
+                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
+            )
+
+        if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
+                llm_output=text,
+                send_to_llm=True,
+            )
+        elif not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        ):
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
+                llm_output=text,
+                send_to_llm=True,
+            )
+        else:
+            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+
+    @property
+    def _type(self) -> str:
+        return "react-single-input-without-markdown"
+    
+def remove_markdown_code_block(text: str):
+    pattern = re.compile(r"```sql\s*(.*?)\s*```", re.DOTALL)
+    
+    # 查找匹配的内容
+    match = pattern.search(text)
+    if match:
+        # 提取 SQL 语句
+        sql_query = match.group(1)
+        return sql_query.strip()
+    else:
+        return "No SQL code block found."
--- a/sqlcode/store_vecstore.py
+++ b/sqlcode/store_vecstore.py
@ -0,0 +1,17 @@
+from langchain_community.document_loaders import TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_chroma import Chroma
+import os
+from langchain_community.embeddings import DashScopeEmbeddings
+
+ENVIRONMENT = os.environ.get('ENVIRONMENT', 'development')
+DIR_NAME = os.path.dirname(__file__)
+path = os.path.join(DIR_NAME, '..','config',ENVIRONMENT,"rag.txt")
+loader = TextLoader(file_path=path)
+
+docs = loader.load()
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=100)
+splits = text_splitter.split_documents(docs)
+out_dir = os.path.join(DIR_NAME, '..', 'chroma_db')
+vectorstore = Chroma.from_documents(documents=splits, embedding=DashScopeEmbeddings(), persist_directory=out_dir)
+print("向量数据库更新完毕")
--- a/sqlcode/tt_tencent.py
+++ b/sqlcode/tt_tencent.py
@ -0,0 +1,50 @@
+from tencentcloud.common import credential
+from tencentcloud.common.profile.client_profile import ClientProfile
+from tencentcloud.common.profile.http_profile import HttpProfile
+from tencentcloud.tmt.v20180321 import tmt_client, models
+
+class Translator:
+    def __init__(self, secret_id:str, secret_key:str, *, 
+                 region: str = 'ap-guangzhou'):
+        # 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
+        # 代码泄露可能会导致 SecretId 和 SecretKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考，建议采用更安全的方式来使用密钥，请参见：https://cloud.tencent.com/document/product/1278/85305
+        # 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
+        # 实例化一个http选项，可选的，没有特殊需求可以跳过
+        httpProfile = HttpProfile()
+        httpProfile.endpoint = "tmt.tencentcloudapi.com"
+
+        # 实例化一个client选项，可选的，没有特殊需求可以跳过
+        clientProfile = ClientProfile()
+        clientProfile.httpProfile = httpProfile
+        cred = credential.Credential(secret_id=secret_id, secret_key=secret_key)
+        self.client = tmt_client.TmtClient(credential=cred, region=region, profile=clientProfile)
+        
+        
+    def translate(self, text: str, *, 
+                  source: str|None = 'auto', 
+                  target: str|None = 'zh', 
+                  project_id: int|None = None, 
+                  untranslated_text: str|None = None
+                  ) -> str:
+        # 实例化一个请求对象,每个接口都会对应一个request对象
+        req = models.TextTranslateRequest()
+        req.SourceText = text
+        req.Source = source
+        req.Target = target
+        req.ProjectId = project_id or 0
+        req.UntranslatedText = untranslated_text
+
+        # 返回的resp是一个TextTranslateResponse的实例，与请求对象对应
+        resp = self.client.TextTranslate(req)
+        # 输出json格式的字符串回包
+        return resp.TargetText
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--secret_id', type=str, required=True)
+    parser.add_argument('--secret_key', type=str, required=True)
+    args = parser.parse_args()
+    t = Translator(args.secret_id, args.secret_key)
+    r = t.translate('branch_company | number_of_contracts | total_contract_amount'.replace('_', ' '), untranslated_text='|')
+    print(r)
--- a/sqlcode/utils.py
+++ b/sqlcode/utils.py
@ -0,0 +1,15 @@
+
+def enrich_input(message: str, input: dict) -> dict:
+    pre_messages = input["messages"]
+    problem = input["messages"][0][1]
+    print("human", message + " " + problem)
+    input["messages"] = pre_messages + [("human", message + " " + problem)]
+    input["iterations"] = 0
+    return input
+
+def parse(res: str) -> str:
+    """将优化后的问题提取出来"""
+    return res.split("优化后的问题：",1)[-1]
+
+def format_docs(docs):
+    return "\n\n".join(doc.page_content for doc in docs)
--- a/start-in-docker.sh
+++ b/start-in-docker.sh
@ -0,0 +1,28 @@
+#!bash
+
+set -xue
+
+venv=/root/miniconda3/envs/bizwechat
+workdir=$(dirname $(realpath $0))
+name=$(basename $workdir)
+
+[ -d "$venv" ] || (echo "venv $venv not exists" && exit 1)
+
+cd $workdir || (echo "cd $workdir failed" && exit 1)
+
+. "$workdir/.env"
+
+[ -e "log" ] || mkdir log
+
+docker run -d --stop-signal INT --replace \
+  --ip $UVICORN_HOST \
+  -v "$venv:$venv" \
+  -v "$workdir:$workdir" \
+  --name "$name" \
+  --env-file "$workdir/.env" \
+  --workdir "$workdir" \
+  --restart unless-stopped \
+  debian:bookworm \
+  "$venv/bin/uvicorn" main:app --log-config "config/$ENVIRONMENT/logging.yaml" $@
+
+docker logs -f "$name"
--- a/test.sh
+++ b/test.sh
@ -0,0 +1,11 @@
+curl localhost:9000/qwen/contracts?apikey=YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI \
+    -H "Content-Type: application/json" \
+    -d '{"return_type":"text","question":"2024年项目的平均金额为？"}'
+
+#    -d '{"return_type":"text","question":"2023公司承接的“合同名称”或“专业”包含工程施工的项目有哪些？列出“合同名称”, “签订日期”, “专业”。使用模糊匹配，参考SQL语句：SELECT `合同名称`, `签订日期`, `专业`  FROM contracts   WHERE `合同名称` LIKE '%工程施工%' OR `专业` LIKE '%工程施工%'（AND 根据2023设置`签订时间`的年份或月份范围） LIMIT 15"}'
+
+#    -d '{"return_type":"text","question":"2022公司承接的“客商类型”或“客户名称”包含中国电信的项目有哪些？列出“合同名称”“签订时间”“客商类型”。使用模糊匹配，参考SQL语句：SELECT `合同名称`, `签订日期`, `客商类型`FROM contracts  Where `客户名称` LIKE '%中国电信%' OR `客商类型` LIKE '%中国电信%' （AND 根据2022设置`签订时间`的年份或月份范围"}'
+
+#    -d '{"return_type":"text","question":"2020到2024年承接的地点在“四川省”的“合同签订金额”100万到1000万的项目有哪些？今年是2024年。参考sql语句： SELECT `合同名称`, `地点`, `签订日期`, `合同签订金额（人民币）` FROM contracts  WHERE `地点` LIKE '%四川省%' AND `合同签订金额（人民币）` >= money   AND `签订日期` BETWEEN time1 AND time2"}'
+
+
--- a/test_acc.py
+++ b/test_acc.py
@ -0,0 +1,319 @@
+import requests
+import json
+import pandas as pd
+import random
+from itertools import product 
+
+template_list = [
+    {   # 时间、客户、公司
+        "keys": ['time', 'customer', 'company'],
+        "sql": """
+        SELECT `合同名称`, `签订日期`, `客户名称`, `所属分公司`
+        FROM contracts 
+        WHERE `所属分公司` LIKE '%{company}%'
+        AND `客户名称` LIKE '%{customer}%' OR `客商类型` LIKE '%{customer}%' OR `合同名称` LIKE '%{customer}%' 
+        （AND 根据{time}设置`签订时间`的筛选范围）""",
+        "question": "{time}{company}承接的“客户名称”或“客商类型”或“合同名称”包含{customer}的项目有哪些？参考sql语句：[sql]",
+    },
+    {   # 时间、行业（包括专业）
+        "keys": ['time', 'field'],
+        "sql": """
+        SELECT `合同名称`, `签订日期`, `聚焦行业` 
+        FROM contracts 
+        WHERE `合同名称` LIKE '%{field}%' OR `聚焦行业` LIKE '%{field}%' OR `专业` LIKE '%{field}%'
+        （AND 根据{time}设置`签订时间`的筛选范围）""",
+        "question": "{time}承接的“聚焦行业”或“行业”包含{field}的项目有哪些？参考sql语句：[sql]"
+    },
+    {   # 时间、公司、专业
+        "keys": ['time', 'company', 'major'],
+        "sql": """
+        SELECT `合同名称`, `签订日期`, `专业`, `所属分公司`
+        FROM contracts 
+        WHERE `合同名称` LIKE '%{major}%' OR `专业` LIKE '%{major}%' 
+        AND `所属分公司` LIKE '%{company}%'
+        （AND 根据{time}设置`签订时间`的筛选范围）""",
+        "question": "{time}{company}承接的“专业”包含{major}的项目有哪些？参考sql语句：[sql]"
+    },
+    {   # 时间、地点
+        "keys": ['time', 'area'],
+        "sql": """
+        SELECT `合同名称`, `地点`
+        FROM contracts 
+        WHERE `地点` LIKE '%{area}%'
+        （AND 根据{time}设置`签订时间`的筛选范围）""",
+        "question": "{time}承接的地点在“{area}”的项目有哪些？参考sql语句：[sql]",
+    },
+    {   # 关键字查询（专业、行业、公司、客户、地点）
+        "keys": ['keyword'],
+        "sql": """
+        SELECT `合同名称`, `所属分公司`, `专业`, `聚焦行业`, `客商类型`, `地点`
+        FROM contracts 
+        WHERE `合同名称` LIKE '%{keyword}%' OR `聚焦行业` LIKE '%{keyword}%' 
+        OR `所属分公司` LIKE '%{keyword}%' OR `客商类型` LIKE '%{keyword}%'
+        OR `地点` LIKE '%{keyword}%' OR `客户名称` LIKE '%{keyword}%'
+        OR `专业` LIKE '%{keyword}%'""",
+        "question": "“地点”“专业”“聚焦行业”“所属分公司”“客商类型”“客户名称”或“合同名称”包含{keyword}的项目有哪些？参考sql语句：[sql]",
+    },
+    {   # 公司、金额
+        "keys": ['company', 'money'],
+        "sql": """
+        SELECT `合同名称`, `所属分公司`, `合同签订金额（人民币）`
+        FROM contracts 
+        WHERE `公司` LIKE '%{company}%'
+        （AND 根据{money}筛选`合同签订金额（人民币）`的筛选范围）""",
+        "question": "{company}的合同金额{money}的项目有哪些？参考sql语句：[sql]"
+    }]
+
+raw_data = {
+    'time': list(pd.read_excel("./valueSets.xlsx", sheet_name="时间取值")["时间取值"]),
+    'major': list(pd.read_excel("./valueSets.xlsx", sheet_name="专业取值")["专业取值"]),
+    'company': list(pd.read_excel("./valueSets.xlsx", sheet_name="公司取值")["公司取值"]),
+    'field': list(pd.read_excel("./valueSets.xlsx", sheet_name="行业取值")["行业取值"]),
+    'customer': list(pd.read_excel("./valueSets.xlsx", sheet_name="客户取值")["客户取值"]),
+    'area': list(pd.read_excel("./valueSets.xlsx", sheet_name="地区取值")["地区取值"]),
+    'money': [ "100万以上的", "50万以上的", "2000万以上", "400万以上", "10万以上", "100万到1000万",], # 金额范围取值
+}
+raw_data['keyword'] = [item for key in ['area', 'company', 'customer', 'major', 'field'] for item in raw_data[key]]
+
+def combine_key_val(keys: list, k=4) -> dict:
+    """
+    计算不同字段的排列组合
+    Args:
+        keys (_type_): 字段名列表
+        k (int, optional): 每个字段的取值数量. Defaults to 4.
+
+    Returns:
+        list: [{key1: value1}]字典列表
+        
+    """
+    tmp = {}
+    for key in keys:
+        value = raw_data.get(key, [])
+        # if key == 'company':
+        #     tmp[key] = ['一分公司']
+        # else:
+        #     k = len(value) if k > len(value) else k  
+        #     tmp[key] = random.sample(value, k=k)
+        k = len(value) if k > len(value) else k  
+        tmp[key] = random.sample(value, k=k)
+    print(tmp)
+    # 计算笛卡尔积
+    keys = list(tmp.keys())
+    values = list(tmp.values())
+    combinations = list(product(*values))
+    # 将每个组合转换为字典
+    return [{key: value for key, value in zip(keys, combination)} for combination in combinations]
+
+
+def form_question(keys, k) -> list:
+    """根据选填字段生成问题
+
+    Args:
+        keys (_type_): _description_
+
+    Returns:
+        list: _description_
+    """
+    combination_dict = combine_key_val(keys, k=k)
+    print(len(combination_dict))
+    template_idx = 0
+    for index, item in enumerate(template_list):
+        if set(item['keys']) == set(keys):
+            template_idx = index
+            break
+    template = template_list[template_idx]
+    question_template = template['question'].replace('[sql]', template['sql'])
+    
+    question_list = []
+    tmp = ''
+    for combination in combination_dict:
+        tmp = question_template
+        tmp = tmp.format_map(combination)
+        question_list.append(tmp)
+    return question_list
+
+
+def test(keys, k=3):
+    question_list = form_question(keys, k=k)
+    try:
+        res = [["问题", "sql", "回答", "thought"]]
+        for question in question_list:
+            if question == "":
+                break
+            payload = {"return_type": "text", "question": question}
+            response = requests.post(url, headers=headers, data=json.dumps(payload))
+            response_data = response.json()
+            print("data_res", response_data)
+            res.append(
+                [
+                    question,
+                    response_data["sql"],
+                    response_data["result"],
+                    response_data["thought"],
+                ]
+            )
+            data = pd.DataFrame(res)
+            data.to_excel("./output/{}.xlsx".format('-'.join(keys)), index=False)
+    except Exception as error:
+        print("Error:", error)
+        return "Error"
+
+url = "http://localhost:8001/qwen/contracts?apikey=YUVietLgiGmtqzYUVIIGjrNoLMsGM0FI"
+headers = {
+    "Content-Type": "application/json",
+    # Uncomment the following line if needed and provide the appropriate value for data['apiKey']
+    # 'Authorization': f'Bearer {data["apiKey"]}'
+}
+
+
+# # def some_function():
+#     # print(pdata["问题"])
+
+#     ls = pdata["问题"]
+#     qs = []
+#     tmp = []
+#     res_q = []
+#     # for ll in ["数据库字段中的“合同名称”或“聚焦行业”或“专业”包含“key”的项目有哪些?"]:
+#     # for ll in ["time公司承接的money的项目有哪些/多少？今年是2024年。"]:
+#     # for ll in ["time公司承接的customer的项目有哪些/多少？其中，值为“customer”是数据库中“客商类型”字段的部分内容。今年是2024年。"]:
+#     for ll in [
+#         "company time承接的field的项目有哪些？其中，值为“company”是数据库中“所属分公司”字段的部分内容，“field”是数据库中“合同名称”或“聚焦行业”字段的部分内容。今年是2024年。"
+#     ]:
+#         # for ll in ["time公司承接的field的项目有哪些/多少？其中，值为“field”是数据库中“合同名称”或“聚焦行业”字段的部分内容。"]:
+
+#         qs = []
+#         tmp = []
+#         tmp.append(ll)
+#         if "time" in ll:
+#             for ts in time:
+#                 t0 = ll.replace("time", ts)
+#                 qs.append(t0)
+#             tmp = qs
+#             qs = []
+
+#         for t1 in tmp:
+#             if "major" in t1:
+#                 for sp in major:
+#                     t0 = t1.replace("major", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         for t1 in tmp:
+#             if "company" in t1:
+#                 for sp in company:
+#                     t0 = t1.replace("company", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         for t1 in tmp:
+#             if "field" in t1:
+#                 for sp in field:
+#                     t0 = t1.replace("field", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         for t1 in tmp:
+#             if "key" in t1:
+#                 for sp in key:
+#                     t0 = t1.replace("key", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         # money
+#         for t1 in tmp:
+#             if "money" in t1:
+#                 for sp in money:
+#                     t0 = t1.replace("money", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         for t1 in tmp:
+#             if "customer" in t1:
+#                 for sp in customer:
+#                     t0 = t1.replace("customer", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         tmp = qs
+#         qs = []
+
+#         for t1 in tmp:
+#             if "area" in t1:
+#                 for sp in area:
+#                     t0 = t1.replace("area", sp)
+#                     qs.append(t0)
+#             else:
+#                 qs.append(t1)
+
+#         # tmp = qs
+#         # qs = []
+#         # print(len(qs))
+#         res_q = [*res_q, *qs]
+#     print(len(res_q))
+#     # print(res_q)
+
+#     # return
+#     try:
+#         res = [["问题", "sql", "回答", "thought"]]
+
+#         for ll in res_q:
+#             if ll == "":
+#                 break
+#             payload = {"return_type": "text", "question": ll}
+#             response = requests.post(url, headers=headers, data=json.dumps(payload))
+#             response_data = response.json()
+#             print("data_res", response_data)
+#             res.append(
+#                 [
+#                     ll,
+#                     response_data["sql"],
+#                     response_data["result"],
+#                     response_data["thought"],
+#                 ]
+#             )
+#             data = pd.DataFrame(res)
+#             data.to_excel("./行业-时间.xlsx", index=False)
+#     except Exception as error:
+#         print("Error:", error)
+#         return "Error"
+
+
+if __name__ == "__main__":
+    keys_combination_list = [
+        ['time', 'customer', 'company'],
+        ['time', 'field'],
+        ['time', 'company', 'major'],
+        ['time', 'area'],
+        ['keyword'],
+        ['company', 'money']
+    ]
+    # print(form_question(keys_combination_list[0]))
+    # form_question(keys_combination_list[2],k=3)
+    # test(keys_combination_list[0], k=3)
+    # test(keys_combination_list[1], k=3)
+    # test(keys_combination_list[2], k=3)
+    # test(keys_combination_list[3], k=3)
+    # test(keys_combination_list[4], k=20)
+    test(keys_combination_list[5], k=3)
+    
--- a/tgi_app.py
+++ b/tgi_app.py
@ -0,0 +1,43 @@
+import fastapi
+import config
+from http import HTTPStatus
+from pydantic import BaseModel, Field
+from typing import Any
+from sqlcode.qwenapi import Generator
+
+app = fastapi.FastAPI()
+
+class Request(BaseModel):
+    inputs: str = Field(description='Prompt')
+    parameters: Any | None = Field(default=None, description='Generation parameters')
+    stream: bool = Field(default=False, description='Whether to stream output tokens')
+
+class Response(BaseModel):
+    generated_text: str = Field(description='Generated text')
+    details: Any = Field(default=None, description='Generation details')
+
+@app.post('/{model}')
+async def generate(model:str, apikey:str, req:Request) -> Response:
+    client = config.api_key(apikey)
+    if not client:
+        raise fastapi.HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail='invalid apikey')
+    
+    message = [{'role': 'system',
+                'content': '你擅长编写 MySQL 的 SQL 代码，请结合具体问题编写正确规范的 SQL 代码'
+                }]
+      
+    generator = Generator(model=model, 
+                          messages=message, 
+                          apikey=client.dashscope_api_key,
+                          seed=0,
+                          )
+    prompt = req.inputs
+    
+    if (n1:=prompt.find('[QUESTION]')) >= 0 and (n2:=prompt.find('[/QUESTION]')) >= n1:
+        question = prompt[n1+10:n2]
+    else:
+        question = 'UNKNOWN'
+
+    ret = generator.generate(question, prompt)
+
+    return Response(generated_text=(ret.sql or ''))
--- a/valueSets.xlsx
+++ b/valueSets.xlsx
--- a/wechat.py
+++ b/wechat.py
@ -0,0 +1,233 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+"""
+微信企业后台 接口.
+"""
+
+import xml.etree.cElementTree as ET
+from bizwechat import WXBizMsgCrypt
+from http import HTTPStatus
+import fastapi
+import logging
+import config
+import asyncio
+import aiohttp
+from sqlcode.sql_agent import create_sql_agent, remove_markdown_code_block
+from langchain_community.agent_toolkits import SQLDatabaseToolkit
+from langchain_community.utilities import SQLDatabase
+from langchain.agents.agent_types import AgentType
+from langchain_core.tools import StructuredTool
+from langchain.prompts import PromptTemplate
+from langchain_chroma import Chroma
+from langchain_community.embeddings import DashScopeEmbeddings
+from sqlcode.utils import parse, format_docs
+from langchain_core.runnables import RunnablePassthrough
+from sqlcode.multi_agent import create_sql_graph
+
+app = fastapi.FastAPI()
+logger = logging.getLogger('sqlcode')
+
+def get_wxcpt():
+    '''
+    创建微信企业后台接口的加密解密对象
+    '''
+    wxbiz_config = config.bizwechat_config()
+    return WXBizMsgCrypt(sToken=wxbiz_config.token, 
+                         sEncodingAESKey=wxbiz_config.aes_key, 
+                         sReceiveId=wxbiz_config.corp_id)
+
+
+@app.get('/', include_in_schema=False)
+async def verify_url(request:fastapi.Request):
+    '''
+    验证微信公众号的请求URL的合法性
+    '''
+    signature = request.query_params.get('msg_signature')  
+    timestamp = request.query_params.get('timestamp')  
+    nonce = request.query_params.get('nonce')
+    echostr = request.query_params.get('echostr')  
+    
+    if not signature or not timestamp or not nonce or not echostr:
+        logger.error('verify_url failed, missing parameters')
+        return fastapi.Response('', HTTPStatus.BAD_REQUEST)
+    
+    code, echostr = get_wxcpt().VerifyURL(signature, timestamp, nonce, echostr)
+
+    if code == 0:
+        logger.info('verify_url success, echostr: %s', echostr)
+        return fastapi.Response(echostr, HTTPStatus.OK)
+    else:
+        logger.error('verify_url failed, error code: %s', code)
+        return fastapi.Response('', HTTPStatus.BAD_REQUEST)
+    
+
+@app.post('/', include_in_schema=False)
+async def receive_message(request:fastapi.Request):
+    '''
+    接收微信公众号消息，并回复
+    '''
+    signature = request.query_params.get('msg_signature')  
+    timestamp = request.query_params.get('timestamp')  
+    nonce = request.query_params.get('nonce')
+    
+    if not signature or not timestamp or not nonce:
+        logger.error('receive_message failed, missing parameters')
+        return '', HTTPStatus.BAD_REQUEST
+    
+    logger.info('receive_message timestamp: %s, nonce: %s', timestamp, nonce)
+
+    post_data = await request.body()
+    code, post_data = get_wxcpt().DecryptMsg(post_data, signature, timestamp, nonce)
+    
+    if code != 0:
+        logger.error('receive_message failed, error code: %s', code)
+        return '', HTTPStatus.BAD_REQUEST
+    
+    xml = ET.fromstring(post_data)
+    content = xml.find('Content').text
+    from_user = xml.find('FromUserName').text
+    
+    asyncio.create_task(async_query_and_reply( 
+                    apikey=config.bizwechat_config().qgi_api_key, 
+                    model_name='qwen', 
+                    database='contracts', 
+                    question=content,
+                    to_user=from_user,
+                    ))
+        
+    logger.info('receive_message success, timestamp: %s, nonce: %s', timestamp, nonce)
+    return ''
+    
+    
+from sqlcode.qgi import Executor, NewFormatter, ReturnType
+# from sqlcode.qwenapi import Generator
+from sqlcode.langchain_model import Generator
+from sqlcode.modelloader import ModelLoader, ModelManager
+
+async def async_query_and_reply(apikey:str, model_name:str, database:str, question:str, to_user:str):
+    """
+    根据请求执行查询并返回结果。
+
+    该函数接收一个模型名称、数据库名称和一个请求对象，通过这些信息来执行特定的查询操作。
+    查询的结果会根据请求中指定的返回类型进行处理和包装。
+
+    * :param model: 字符串类型，表示要使用的大模型的名称。例如 qwen-turbo 等
+    * :param database: 字符串类型，表示要查询的数据库的名称。
+    * :param req: Request 类型的对象，包含查询的具体问题和期望的返回类型。
+    """
+    logger.info('开始处理问题：%s', question)
+    metadata = config.metadata(database)
+    qwen_cfg = config.qwen_config("qwen_graph.conf")
+    re_cfg = config.refineProblem_config()
+    
+    modelLoader = ModelLoader(config.model_config())
+    modelManager = ModelManager(modelLoader)
+    modelManager.switch_model(model_name)
+    model = modelManager.get_model()
+    
+    # db_dir = "chroma_db"
+    # # 需要先检查向量数据库是否为最新，执行sqlcode/store_vecstore.py来更新向量数据库
+    # vectorstore = Chroma(persist_directory=db_dir, embedding_function=DashScopeEmbeddings())
+    # retriever = vectorstore.as_retriever(search_kwargs={'k': 2})
+    # re_prompt = PromptTemplate.from_template(re_cfg.prompt)
+    # context_chain = retriever | format_docs
+    # context = context_chain.invoke(question)
+    # rag_chain = (
+    #     {"context": lambda x: context, "question": RunnablePassthrough()}
+    #     | re_prompt
+    #     | model
+    #     | parse
+    # )
+    # refine_question = rag_chain.invoke(question)
+    
+    # db = SQLDatabase.from_uri(metadata.connection_string)
+    # toolkit = SQLDatabaseToolkit(db=db, llm=model)
+    # remove_markdown_tool = StructuredTool.from_function(
+    #     func=remove_markdown_code_block,
+    #     description="当发生因为markdown标记导致的函数输入错误时，可以调用此函数来删除标记",
+    #     name="remove_markdown_code_block"
+    # )
+    # prompt = PromptTemplate.from_template(qwen_cfg.prompt)
+    # prompt = prompt.partial(metadata=metadata.metadata, product=metadata.product, example=qwen_cfg.params["example"], context=context)
+    # agent_executor = create_sql_agent(
+    #     llm=model,
+    #     prompt=prompt,
+    #     toolkit=toolkit,
+    #     verbose=True,
+    #     agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    #     extra_tools=[remove_markdown_tool],
+    #     agent_executor_kwargs={"handle_parsing_errors": True}
+    # )
+    
+    agent_executor = create_sql_graph(model=model, qwen_cfg=qwen_cfg, data_cfg=metadata)
+    
+    formatter = NewFormatter(format=ReturnType.WX_MD, 
+                             tranlate=None, 
+                             output_dir=config.osp.join(config.BASE_DIR, 'output'), 
+                             site_url=config.app_config().site_url + '/output',
+                             )
+    
+    generator = Generator(agentExcutor=agent_executor, 
+                          messages=[{'role': 'system', 'content': qwen_cfg.system}], 
+                          apikey=config.api_key(apikey).dashscope_api_key,
+                          seed=0,
+                          )
+    
+    executor = Executor(generator=generator, formatter=formatter)
+
+    # input = {"input": question, "refined_question": refine_question}
+    input = {"messages": [("human", question)], "iterations": 0}
+    ret = executor.query(connection_string=metadata.connection_string,
+                         input=input,
+                         )
+    
+    # thought and result 分开发送因为消息大小限制为 2048 字节(utf-8)
+    await send_msg(to_user, question, ret.error)
+    if ret.thought.startswith('```') and ret.thought.endswith('```'):
+        await send_msg(to_user, question, '针对这个问题，采用 SQL 查询：\n' + ret.thought)
+    else:
+        await send_msg(to_user, question, ret.thought)
+    await send_msg(to_user, question, ret.result)
+
+async def send_msg(to_user:str, question:str, content:str):
+    '''
+    发送问题的回复给指定用户
+    '''
+    if not content:
+        return
+    
+    msg = {
+        "touser" : to_user,
+        "msgtype": "markdown",
+        "agentid" : config.bizwechat_config().agent_id,
+        "markdown": {"content": content,},
+    }
+    access_token = config.wxbiz_token()
+    url = f"https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token={access_token}"
+    
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json=msg) as resp:
+            resp_text = await resp.text()
+            logger.debug('send_msg to %s %s: %s', to_user, question, resp_text)
+
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) > 1 and sys.argv[1] == 'test':
+        logging.basicConfig(level=logging.DEBUG)
+        asyncio.run(async_query_and_reply(apikey=config.bizwechat_config().qgi_api_key, 
+                                model='qwen-max', 
+                                database='contracts', 
+                                question="2020年业绩最好的分公司",
+                                to_user='SunHaiWen',
+                                ))
+    elif len(sys.argv) > 1 and sys.argv[1] == 'send':
+        logging.basicConfig(level=logging.DEBUG)
+        asyncio.run(send_msg(to_user='SunHaiWen', 
+                              question="2020年业绩最好的分公司", 
+                              content="2020年业绩最好的分公司是北京分公司",
+                              ))
+    else:
+        import uvicorn
+        uvicorn.run(app, host='0.0.0.0', port=9000)
				`@ -0,0 +1 @@`
				`# 请将伪静态规则或自定义Apache配置填写到此处`