ChatIE项目工程化重构

ChatIE/
├─ .github/
│  └─ workflows/
│     └─ deploy-banked.yml
├─ src/
│  ├─ assets/
│  │  ├─ system_prompt/
│  │  └─ global.css
│  ├─ components/
│  │  ├─ FormSection.vue
│  │  ├─ MainContainer.vue
│  │  ├─ MainPage.vue
│  │  ├─ NetworkVis.vue
│  │  └─ ResultSection.vue
│  ├─ composables/
│  │  ├─ api.js
│  │  ├─ callAPI.js
│  │  ├─ loadPattern.js
│  │  └─ useData.js
│  ├─ store/
│  │  ├─ index.js
│  │  └─ storeData.js
│  ├─ utils/
│  │  ├─ regs.js
│  │  └─ vis_utils.js
│  ├─ App.vue
│  ├─ main.js
│  └─ style.css
├─ .gitignore
├─ app.py
├─ index.html
├─ package-lock.json
├─ package.json
├─ README.md
├─ requirements.txt
└─ vite.config.js

<template>
  <FormSection
    @update:selected-pattern="(newPattern) => Object.assign(selectedPattern, newPattern)"
    @update:users-input-form="(newUsersInput) => Object.assign(usersInputForm, newUsersInput)"
    @submit="submitInput"
    @clear="clearInput"
    :selected-pattern="selectedPattern"
    :users-input-form="usersInputForm"
    :isLoading="isLoading"
  />
  <NetworkVis :response-data="result" />
  <ResultSection :response-data="result" />
</template>

<script setup>
const props = defineProps({
  selectedPattern: { type: Object, required: true },
  usersInputForm: { type: Object, required: true },
  isLoading: { type: Boolean, default: false },
});

const emit = defineEmits([
  "update:selected-pattern",
  "update:users-input-form",
  "submit", 
  "clear"
]);

const localPattern = reactive({ ...props.selectedPattern });

watch(localPattern, (newValue) => {
  emit("update:selected-pattern", { ...newValue });
}, { deep: true });

const submmitInput = () => {
  emit("submit");
};
</script>

<script setup>
const props = defineProps({
  responseData: { type: String, default: "" }
});

watch(() => props.responseData, (newValue) => {
  if (newValue) {
    result.value = { ...mdConverter(newValue) };
    updateNetwork(result.value);
  } else {
    nodes.clear();
    edges.clear();
  }
});
</script>

export async function loadPattern() {
  try {
    if (storeData.getUsersPattern()) {
      const pattern = JSON.parse(storeData.getUsersPattern());
      storeData.setPattern(pattern);
    } else {
      const language = storeData.getLanguage();
      const model = storeData.getModel();
      const file = `default_match_pattern.json`;
      const response = await fetch(file); 

      if (!response.ok) {
        throw new Error(`failed loading default pattern: ${response.status}`);
      }

      const data = await response.json();
      const default_pattern = data[language][model];

      storeData.setPattern(default_pattern);
    }
  } catch (error) {
    throw new Error(`不合法的JSON格式，请检查：${error}`);
  }
}

export async function buildPrompt(stage) {
  //stage: string -> "stage_1" "stage_2"
  const language = storeData.getLanguage();
  const model = storeData.getModel();
  const promptFile = `system_prompt/${model}/${stage}/${language}.prompt`;

  const response = await fetch(promptFile);

  if (!response.ok) {
    throw new Error(`failed loading prompt: ${response.status}`);
  }

  const orginal_prompt = await response.text();
  return orginal_prompt;
}

export function replacePrompt(stage, orginal_prompt, result_of_stage1) {
  const sentence = storeData.getSentence();
  const model = storeData.getModel();
  const pattern = storeData.getPattern();

  let prompt = "";

  switch (model) {
    case "RE":
      switch (stage) {
        case "stage_1":
          orginal_prompt = orginal_prompt.replace("$sentence", sentence);
          prompt = orginal_prompt.replace("$relations", pattern["rtl"]);
          break; 

        case "stage_2":
          orginal_prompt = orginal_prompt.replace(/\$stl/g, pattern["stl"]); //replace all
          orginal_prompt = orginal_prompt.replace(/\$otl/g, pattern["otl"]);
          prompt = orginal_prompt.replace("$relation", result_of_stage1);
          break;
      }
      break;

    case "EE":
      switch (stage) {
        case "stage_1":
          orginal_prompt = orginal_prompt.replace("$sentence", sentence);
          prompt = orginal_prompt.replace(
            "$etl",
            JSON.stringify(pattern["etl"])
          );
          break;

        case "stage_2":
          orginal_prompt = orginal_prompt.replace(
            "$etl",
            JSON.stringify(pattern["etl"])
          );
          prompt = orginal_prompt.replace("$first_stage", result_of_stage1);

          break;
      }
      break;

    case "NER":
      switch (stage) {
        case "stage_1":
          orginal_prompt = orginal_prompt.replace("$sentence", sentence);
          prompt = orginal_prompt.replace("$etl", pattern["etl"]);
          break;

        case "stage_2":
          prompt = orginal_prompt.replace("$etl", pattern["etl"]);
          break;
      }
      break;
  }
  return prompt;
}

function convertRE(markdown) {
  const lines = markdown.split("\n").filter((line) => line.trim() !== "");
  
  if (lines.length < 2) {
    return { stl: [], otl: [], relation: [] };
  }

  const stl = [];
  const otl = [];
  const relation = [];

  for (let i = 2; i < lines.length; i++) {
    const row = lines[i]
      .split("|")
      .map((cell) => cell.trim())
      .filter((cell) => cell !== "");

    stl.push(row[0]);
    otl.push(row[1]);
    relation.push(row[2]);
  }

  return { stl, otl, relation };
}

app = Flask(__name__)

CORS(app, resources= {
    r"/api/call_doubao": {
        "origins": ["http://localhost:5173", "http://chatie.service.2jone.top"],
    }
})

DOUBAO_KEY = os.environ.get("DOUBAO_API_KEY")

@app.route("/api/call_doubao", methods=["POST"])
def call_doubao_api():
    try:
        data = request.get_json()
        messages = data.get("messages", [])
        users_api_key = data.get("apiKey", "")
        API_Key = users_api_key if users_api_key != "" else DOUBAO_KEY

        if not API_Key:
            error_msg = {"error": "还未设置APIKEY到环境变量"}

            return Response(
                json.dumps(error_msg, ensure_ascii=False),
                mimetype="application/json",
                status=500
            )
        
        client = OpenAI(
            base_url="https://ark.cn-beijing.volces.com/api/v3",
            api_key=API_Key
        )

        completion = client.chat.completions.create(
            model="doubao-1-5-pro-32k-250115",
            messages=messages
        )

        result = completion.choices[0].message.content

        return Response(
            json.dumps({"result": result}),
            mimetype="application/json",
            status=200
        )

    except Exception as e:
         return Response(
            json.dumps({"error": f"服务器端出错了：{str(e)}"}, ensure_ascii=False),
            mimetype="application/json",
            status=500
        )

pip insatll gunicorn

gunicorn [OPTIONS] APP_MODULE
 
# app:app [project name]:[service name]
gunicorn -w 4 -b 0.0.0.0:8000 app:app

#查看进程
ps ax | grep gunicorn

sudo nano /etc/systemd/system/newapp.service

[Unit]
Description= new app
After=network.target

[Service]
User=oneuser
#启动目录
WorkingDirectory=/var/www/appservice
#启动命令
ExecStart=/var/www/appservice/venv/bin/gunicorn -w 4 -b 0.0.0.0:8000 app:app
#崩溃重启
Restart=always

[Install]
WantedBy=multi-user.target

#启动服务
sudo systemctl start newapp

#停止服务
sudo systemctl stop newapp

#重启服务
sudo systemctl restart newapp

#开机自启
sudo systemctl enable newapp

#运行状态
sudo systemctl status newapp

sudo systemctl reload nginx 

sudo systemtcl status nginx