# 本脚本主要练习 
# 1. 声明不同模型agent 
# 2. 通过copilotKit 在 frontend 中直接进行切换调用不同agent

# 涉及前端文件
# 1. frontend/server.ts 在前端注册agent
# 2. frontend/src/main.tsx 在前端调用agent
# 3. frontend/src/App.tsx 在具体组件中切换指定agent

import warnings
from fastapi import FastAPI

# CopilotKit and AG-UI dependencies for the AG-UI server
from ag_ui_langgraph import add_langgraph_fastapi_endpoint
from copilotkit import LangGraphAGUIAgent
from copilotkit import CopilotKitMiddleware

# LangChain agent imports
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver

#  create and start a Google ADK agent on port 8009
from ag_ui_adk import ADKAgent, add_adk_fastapi_endpoint
from google.adk.agents import LlmAgent

# Simple helper that starts the server and manages port conflicts
from helper import start_server
from helper import load_api_keys

from helper import get_ark_api_key
from helper import get_ark_api_base
from helper import get_ark_model_name

ARK_API_KEY = get_ark_api_key()
ARK_API_BASE = get_ark_api_base()
ARK_MODEL_NAME = get_ark_model_name()

load_api_keys()

warnings.filterwarnings("ignore")

# *************************** 建一个LangChain agent ***************************

# Build the AG-UI endpoint into a FastAPI app
# CopilotKit 通过兼容 AG-UI 的 HTTP 端点连接到agent。在这里，将启动一个 FastAPI 服务器并挂载一个 LangGraphAGUIAgent。
app = FastAPI()
graph = create_agent("openai:gpt-4.1")
agent = LangGraphAGUIAgent(
    name="lesson2_agent",
    description="Lesson 2 chart agent",
    graph=graph,
)
add_langgraph_fastapi_endpoint(app=app, agent=agent, path="/")

# Start the server
start_server(app, port=8002)

# Make a pre-built LangChain agent
# CopilotKitMiddleware connects your agent to CopilotKit — it lets the model discover and call frontend tools
# Without the middleware, the agent only sees backend-defined tools.
# CopilotKitMiddleware 是一个中间件，它允许您的代理发现并调用前端工具。
graph = create_agent(
    model=ChatOpenAI(model="gpt-4.1"),
    tools=[],
    middleware=[CopilotKitMiddleware()],
    checkpointer=MemorySaver(),
    system_prompt=("You are a helpful assistant"),
)

# Update the agent's graph (hot reloads) 
# 使用 agent.graph 替换graph
agent.graph = graph 
print("✓ Agent graph updated!")

# *************************** 建一个Google ADK agent ***************************

# create and start a Google ADK agent on port 8009
gemini_agent = LlmAgent(
    name="assistant",
    model="gemini-2.5-flash",
    instruction="Be helpful and fun!",
)

adk_agent = ADKAgent(
    adk_agent=gemini_agent,
    app_name="demo_app",
    user_id="demo_user",
    session_timeout_seconds=3600,
    use_in_memory_services=True,
)

app_adk = FastAPI()
add_adk_fastapi_endpoint(app_adk, adk_agent, path="/")

start_server(app_adk, port=8009)

#* ************************* 建一个火山引擎 ADK agent ***************************

ark_app_sdk = FastAPI()
ark_graph = create_agent(
    model=ChatOpenAI(
        openai_api_key=ARK_API_KEY,
        openai_api_base=ARK_API_BASE,
        model_name=ARK_MODEL_NAME, # 从环境变量读取模型
    ),
    tools=[],
    middleware=[CopilotKitMiddleware()],
    checkpointer=MemorySaver(),
    system_prompt=("You are a helpful assistant"),
)
ark_agent = LangGraphAGUIAgent(
    name="ark_agent",
    description="Ark agent for Lesson 2",
    graph=ark_graph,
)
add_langgraph_fastapi_endpoint(ark_app_sdk, ark_agent, path="/")

# Start the server
start_server(ark_app_sdk, port=8010)

# start_server 适合在 Jupyter Notebook 中运行（daemon 线程）
# 在 Notebook 里，Python 进程（Kernel）一直跑着，所以 daemon 线程也会一直活着
# 线程类型                     主程序退出时          适合场景 
# 守护线程 ( daemon=True )     ✅ 一起被杀掉         Jupyter Notebook、临时后台任务 
# 非守护线程 ( daemon=False )  ❌ 主程序会等它跑完     独立服务、常驻进程

# 下面的循环让终端运行时服务保持活跃
print("\n" + "="*50)
print("✅ 所有服务已启动，按 Ctrl+C 停止")
print("   Agent 服务: http://localhost:8002")
print("   ADK 服务:   http://localhost:8009")
print("   Ark 服务:   http://localhost:8010")
print("="*50)

import time
try:
    while True:
        time.sleep(60)
except KeyboardInterrupt:
    print("\n\n🛑 服务已停止")
    import sys
    sys.exit(0)

import { HttpAgent } from "@ag-ui/client";
import { LangGraphHttpAgent } from "@copilotkit/runtime/langgraph";
import { CopilotRuntime, createCopilotEndpoint } from "@copilotkit/runtime/v2";
import { serve } from "@hono/node-server";

// 下面这三个agent 都指向后端agent 服务
const langGraphAgent = new LangGraphHttpAgent({
  url: process.env.LANGGRAPH_DEPLOYMENT_URL || "http://localhost:8002",
});

const adkAgent = new HttpAgent({
  url: process.env.ADK_AGENT_URL || "http://localhost:8009",
});

const arkAgent = new HttpAgent({
  url: process.env.ARK_AGENT_URL || "http://localhost:8010",
});

// The CopilotRuntime is the secure bridge between your frontend and agent backend
// 将不同的agent 注册到runtime 中 方便前端调用
const runtime = new CopilotRuntime({
  agents: {
    default: langGraphAgent, // Register  LangChain agent as the default agent
    gemini: adkAgent,
    ark: arkAgent,
  },
});

const app = createCopilotEndpoint({
  runtime,
  basePath: "/api/copilotkit",
});

serve({ fetch: app.fetch, port: 4002 }, () => {
  console.log("CopilotKit API server running at http://localhost:4002");
});

import { CopilotChat } from "@copilotkit/react-core/v2";

export const agentId = "ark"; // 指定用哪个agent 上面注册的名称

export default function App() {
  return <CopilotChat agentId={agentId} />;
}

import { StrictMode } from "react";
import { createRoot } from "react-dom/client";

import { CopilotKit } from "@copilotkit/react-core/v2";
import App from "./App";

import "./globals.css";
import "@copilotkit/react-core/v2/styles.css";

// 通过CopilotKit provider runtimeUrl 连接到agent
createRoot(document.getElementById("root")!).render(
  <StrictMode>
    <main className="h-screen w-screen">
      <CopilotKit runtimeUrl="/api/copilotkit" useSingleEndpoint={false}>
        <App />
      </CopilotKit>
    </main>
  </StrictMode>,
);

import { z } from "zod"

import { FlightCard, FlightCardProps } from "@/components/flight-card";
import { PieChart, PieChartProps } from "@/components/pie-chart";
import { useExampleSuggestions } from "@/hooks/use-example-suggestions";
import { CopilotChat } from "@copilotkit/react-core/v2";
import { useComponent } from "@copilotkit/react-core/v2";

/************ 使用useComponent 注册组件 ************ */
/*
 * 将react 组件直接注册为 a generative UI tool ，在响应中直接渲染组件
 * 注册组件[useComponent](https://docs.copilotkit.ai/generative-ui/your-components/display-only) 
registers a React component as a tool the agent can call inside `<CopilotChat />`. 
You define what's available; the agent picks when to use it.
useComponent({
  name: "component_name",
  description: "description for the agent to know about this component",
  parameters: z.object({ ... }),
  render: MyComponent,
});

- `name` (required `string`): tool name exposed to the model.
- `description` (optional `string`): tells the model when to call this tool.
- `parameters` (optional Zod schema): structured props passed in as arguments.
- `render` (required): a React component (rendered as `<Component {...args} />`), or a function receiving `{ args, status }` for custom rendering (loading states, wrappers, conditional display).
 */
export default function App() {

  // 🪁 Register a component that shows the name of the user
  useComponent({
    name: "showMyName",
    description: "Show the user's name in a card",
    parameters: z.object({ name: z.string() }),
    render: ({ name }) => <div className="bg-blue-500 p-4">Hi, {name}!</div>,
  });

  // 🪁 Resgister a pieChart component to show structured data
  useComponent({
    name: "pieChart",
    description: "Controlled Generative UI that displays data as a pie chart.",
    parameters: PieChartProps,
    render: PieChart,
  });

  // 🪁 Resgister a flightCard component to show flight data
  useComponent({
    name: "flightCard",
    description: "Controlled Generative UI that displays a single flight summary card.",
    parameters: FlightCardProps,
    render: FlightCard,
  });

  // 🪁 Add suggestions to our CopilotChat, will display through buttons
  useExampleSuggestions();

  return <CopilotChat />;

};

import { serve } from "@hono/node-server";
import {
  CopilotRuntime,
  createCopilotEndpoint,
} from "@copilotkit/runtime/v2";
import { LangGraphHttpAgent } from "@copilotkit/runtime/langgraph";

const langGraphAgent = new LangGraphHttpAgent({ url: "http://localhost:8004" });

const runtime = new CopilotRuntime({
  agents: { default: langGraphAgent },
  a2ui: { injectA2UITool: true }, // 启动A2UI 组件 进行组件组装渲染
});

const app = createCopilotEndpoint({
  runtime,
  basePath: "/api/copilotkit",
});

serve({ fetch: app.fetch, port: 4004 }, () => {
  console.log("\u2713 CopilotKit API server running at http://localhost:4004");
});

// frontend/src/catalog/definitions.ts
import { z } from "zod";

export const demonstrationCatalogDefinitions = {
  Title: {
    description: "A heading. Use for section titles and page headers.",
    props: z.object({
      text: z.string(),
      level: z.string().optional(),
    }),
  },
  DashboardCard: {
    description:
      "A card container with title and optional subtitle. Has a 'child' slot for content (chart, metrics, etc). Use 'child' with a single component ID.",
    props: z.object({
      title: z.string(),
      subtitle: z.string().optional(),
      child: z.string().optional(),
    }),
  },
  Metric: {
    description:
      "A key metric display with label, value, and optional trend indicator. Great for KPIs and stats.",
    props: z.object({
      label: z.string(),
      value: z.string(),
      trend: z.enum(["up", "down", "neutral"]).optional(),
      trendValue: z.string().optional(),
    }),
  },

  PieChart: {
    description:
      "A pie/donut chart. Provide data as array of {label, value, color} objects.",
    props: z.object({
      data: z.array(
        z.object({
          label: z.string(),
          value: z.number(),
          color: z.string().optional(),
        }),
      ),
      innerRadius: z.number().optional(),
    }),
  },
  DataTable: {
    description: "A data table with columns and rows.",
    props: z.object({
      columns: z.array(z.object({ key: z.string(), label: z.string() })),
      rows: z.array(z.record(z.any())),
    }),
  }
};

/** Type helper for renderers */
export type DemonstrationCatalogDefinitions =
  typeof demonstrationCatalogDefinitions;

// frontend/src/catalog/renderers.tsx


import React from "react";
import {
  PieChart as RechartsPie,
  Pie,
  Cell,
  ResponsiveContainer,
  BarChart as RechartsBar,
  Bar,
  XAxis,
  YAxis,
  Tooltip,
  CartesianGrid,
} from "recharts";
import {
  createCatalog,
  type CatalogRenderers,
} from "@copilotkit/a2ui-renderer";
import {
  demonstrationCatalogDefinitions,
  type DemonstrationCatalogDefinitions,
} from "./definitions";

function resolveText(value: unknown): string {
  if (typeof value === "string") return value;
  if (value && typeof value === "object" && "path" in value)
    return String((value as { path: string }).path);
  return String(value ?? "");
}

// ─── Renderers (type-checked against schema definitions) ────────────

const demonstrationCatalogRenderers: CatalogRenderers<DemonstrationCatalogDefinitions> =
  {
    Title: ({ props }) => {
      const Tag = (
        props.level === "h1" ? "h1" : props.level === "h3" ? "h3" : "h2"
      ) as "h1" | "h2" | "h3";
      const sizes: Record<string, string> = {
        h1: "1.75rem",
        h2: "1.25rem",
        h3: "1rem",
      };
      return (
        <Tag
          style={{
            margin: 0,
            fontWeight: 600,
            fontSize: sizes[props.level ?? "h2"],
            color: "#111827",
            letterSpacing: "-0.01em",
          }}
        >
          {resolveText(props.text)}
        </Tag>
      );
    }

    Metric: ({ props }) => {
      const trendColors: Record<string, string> = {
        up: "#059669",
        down: "#dc2626",
        neutral: "#6b7280",
      };
      const trendIcons: Record<string, string> = {
        up: "↑",
        down: "↓",
        neutral: "→",
      };
      return (
        <div style={{ display: "flex", flexDirection: "column", gap: "4px" }}>
          <span
            style={{
              fontSize: "0.75rem",
              color: "#6b7280",
              fontWeight: 500,
              textTransform: "uppercase",
              letterSpacing: "0.05em",
            }}
          >
            {resolveText(props.label)}
          </span>
          <div style={{ display: "flex", alignItems: "baseline", gap: "8px" }}>
            <span
              style={{
                fontSize: "1.5rem",
                fontWeight: 700,
                color: "#111827",
                letterSpacing: "-0.02em",
              }}
            >
              {resolveText(props.value)}
            </span>
            {props.trend && props.trendValue && (
              <span
                style={{
                  fontSize: "0.8rem",
                  fontWeight: 500,
                  color: trendColors[props.trend] ?? "#6b7280",
                }}
              >
                {trendIcons[props.trend]} {resolveText(props.trendValue)}
              </span>
            )}
          </div>
        </div>
      );
    },

    PieChart: ({ props }) => {
      const COLORS = [
        "#3b82f6",
        "#8b5cf6",
        "#ec4899",
        "#f59e0b",
        "#10b981",
        "#6366f1",
      ];
      const data = props.data ?? [];
      return (
        <div style={{ width: "100%", height: 200 }}>
          <ResponsiveContainer>
            <RechartsPie>
              <Pie
                data={data}
                dataKey="value"
                nameKey="label"
                cx="50%"
                cy="50%"
                innerRadius={props.innerRadius ?? 40}
                outerRadius={80}
                paddingAngle={2}
              >
                {data.map((entry: any, i: number) => (
                  <Cell
                    key={i}
                    fill={entry.color ?? COLORS[i % COLORS.length]}
                  />
                ))}
              </Pie>
              <Tooltip />
            </RechartsPie>
          </ResponsiveContainer>
        </div>
      );
    },
    DataTable: ({ props }) => {
      const cols = props.columns ?? [];
      const rows = props.rows ?? [];
      return (
        <div style={{ overflowX: "auto", width: "100%" }}>
          <table
            style={{
              width: "100%",
              borderCollapse: "collapse",
              fontSize: "0.8rem",
            }}
          >
            <thead>
              <tr>
                {cols.map((col: any) => (
                  <th
                    key={col.key}
                    style={{
                      textAlign: "left",
                      padding: "8px 12px",
                      borderBottom: "2px solid #e5e7eb",
                      color: "#6b7280",
                      fontWeight: 600,
                      fontSize: "0.7rem",
                      textTransform: "uppercase",
                      letterSpacing: "0.05em",
                    }}
                  >
                    {col.label}
                  </th>
                ))}
              </tr>
            </thead>
            <tbody>
              {rows.map((row: any, i: number) => (
                <tr key={i} style={{ borderBottom: "1px solid #f3f4f6" }}>
                  {cols.map((col: any) => (
                    <td
                      key={col.key}
                      style={{ padding: "8px 12px", color: "#374151" }}
                    >
                      {String(row[col.key] ?? "")}
                    </td>
                  ))}
                </tr>
              ))}
            </tbody>
          </table>
        </div>
      );
    },
  };

// ─── Assembled Catalog ───────────────────────────────────────────────
// 封装定义和render逻辑 之后 注册到provider 上
export const demonstrationCatalog = createCatalog(
  demonstrationCatalogDefinitions,
  demonstrationCatalogRenderers,
  {
    catalogId: "copilotkit://app-dashboard-catalog",
    includeBasicCatalog: false,
  },
);

import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { CopilotKit } from "@copilotkit/react-core/v2";
import "@copilotkit/react-core/v2/styles.css";
import { demonstrationCatalog } from "./catalog/renderers";
import "./globals.css";
import App from "./App";

createRoot(document.getElementById("root")!).render(
  <StrictMode>
    <main className="h-screen w-screen">
      <CopilotKit
        useSingleEndpoint={false}
        runtimeUrl="/api/copilotkit"

        // 🪁 Enable A2UI using the demonstration catalog
        a2ui={{ catalog: demonstrationCatalog }}
      >
        <App />
      </CopilotKit>
    </main>
  </StrictMode>,
);

from copilotkit import a2ui
from langchain.tools import tool

CATALOG_ID = "copilotkit://app-dashboard-catalog"
SURFACE_ID = "flight-search-results"

FLIGHT_SCHEMA = [....] // 定义航班卡片的schema

`@tool
def display_flights(flights: list[Flight]) -> str:
    """Display flights as rich cards in a horizontal row.

    Each flight must have: id, airline, airlineLogo (URL), flightNumber,
    origin, destination, date, departureTime, arrivalTime, duration,
    status, and price.
    """
    return a2ui.render(
        operations=[
            a2ui.create_surface(SURFACE_ID, catalog_id=CATALOG_ID),
            a2ui.update_components(SURFACE_ID, FLIGHT_SCHEMA), // 按schema 渲染
            a2ui.update_data_model(SURFACE_ID, {"flights": flights}),
        ],
    )

graph = create_agent(
    model=ChatOpenAI(model="gpt-4.1"),
    tools=[get_sales_data, search_flights, display_flights],
    middleware=[CopilotKitMiddleware()],
    checkpointer=MemorySaver(),
    system_prompt=(
        "....."
    ),
)

import { LangGraphHttpAgent } from "@copilotkit/runtime/langgraph";
import {
  CopilotRuntime,
  createCopilotEndpoint,
} from "@copilotkit/runtime/v2";
import { serve } from "@hono/node-server";

const appAgent = new LangGraphHttpAgent({
  url: process.env.LANGGRAPH_DEPLOYMENT_URL || "http://localhost:8005",
});

/***
 * 
 * 关于 mcpApps 配置的几点说明：
 * mcpApps.servers 将运行时连接到一个或多个提供应用程序工具的 MCP 服务器。
 * 每个条目都指明了运行时应该在哪里找到兼容的 MCP 应用程序。在这里，你可以通过 HTTP 连接到 Excalidraw。
 * CopilotKit 会自动为代理添加 MCP 应用程序识别功能，从而在运行时能够自动调用这些工具。
 */
const runtime = new CopilotRuntime({
  agents: { default: appAgent },
  openGenerativeUI: true, // 启用开放生成式UI 代理可以生成任意类型的用户界面——包括 HTML、CSS、JavaScript 等代码，并可以直接在聊天界面中展示
  mcpApps: { // 注册 MCP 应用程序
    servers: [
      {
        type: "http",
        url: "https://mcp.excalidraw.com", // <- Exalidraw MCP Server
        serverId: "example_mcp_server",
      },
    ],
  },
});

const app = createCopilotEndpoint({
  runtime,
  basePath: "/api/copilotkit",
});

serve({ fetch: app.fetch, port: 4005 }, () => {
  console.log("✓ CopilotKit API server running at http://localhost:4005");
});

from __future__ import annotations

import uuid

from langchain.agents.middleware import AgentState as BaseAgentState
from langchain.tools import ToolRuntime, tool
from langchain_core.messages import ToolMessage
from langgraph.types import Command
from typing_extensions import TypedDict


class Todo(TypedDict):
    id: str
    title: str
    completed: bool


class AgentState(BaseAgentState):
    todos: list[Todo]

@tool
def manage_todos(todos: list[Todo], runtime: ToolRuntime) -> Command:
    """Replace the entire todo list. Use this to add, edit, or remove todos."""
    for todo in todos:
        if not todo.get("id"):
            todo["id"] = str(uuid.uuid4())

    # Command allows agents to update state via toolcalls
    return Command(update={
        "todos": todos,
        "messages": [
            ToolMessage(
                content="Successfully updated todos",
                tool_call_id=runtime.tool_call_id,
            )
        ],
    })


@tool
def get_todos(runtime: ToolRuntime):
    """Get the current todo list."""
    return runtime.state.get("todos", [])


todo_tools = [manage_todos, get_todos]

graph = create_agent(
    model=ChatOpenAI(
        openai_api_key=ARK_API_KEY,
        openai_api_base=ARK_API_BASE,
        model_name=ARK_MODEL_NAME, # 从环境变量读取模型
    ),
    state_schema=AgentState,
    tools=todo_tools,
    middleware=[CopilotKitMiddleware()],
    checkpointer=MemorySaver(),
    system_prompt=(
        "You manage a shared todo list. "
        "Use manage_todos to add, edit, or remove todos. "
        "Use get_todos to check the current list. "
        "When asked to manage todos, call the openOrCloseTodos frontend tool with open=true first. "
        "Keep responses to 1-2 sentences."
    ),
)

import { useState } from "react";
import { z } from "zod"

import { TodoAppLayout } from "@/components/todo-app-layout";
import { TodoList } from "@/components/todo-list";
import { CopilotChat, useAgent, useFrontendTool } from "@copilotkit/react-core/v2";

/**
 * useAgent() gives you a live handle to the agent's shared state: agent.state.todos reflects the current list, and agent.setState({ todos: updated }) pushes changes back.
 * useFrontendTool registers a tool that runs in the browser — the agent calls it like any backend tool, but the handler executes client-side and can update React state directly.
 */
export default function App() {
  const [todosOpen, setTodosOpen] = useState(false);

  // 🪁 Register a frontend tool the agent can call to control the UI
  useFrontendTool({
    name: "openOrCloseTodos",
    description: "Open or close the todo panel.",
    parameters: z.object({ open: z.boolean()}),
    handler: async ({open}) => {
      setTodosOpen(open);
      return `Todos are ${ open ? 'open' : 'closed'}.`;
    },
  });

  // 🪁 Subscribe to shared agent state
  const { agent } = useAgent();

  return (
    <TodoAppLayout
      chat={<CopilotChat />}
      open={todosOpen}
      onOpenChange={setTodosOpen}
      panel={(onClose) => (
        <TodoList
          // 🪁 Read shared state
          todos={agent.state.todos || []} 

          // 🪁 Write shared state
          onUpdate={(updated) => agent.setState({ todos: updated })}

          isRunning={agent.isRunning}
          onClose={onClose}
        />
      )}
    />
  );
}

import json
import os
import dashscope
from dashscope import MultiModalConversation

# 以下为北京地域url，若使用新加坡地域的模型，需将url替换为：https://dashscope-intl.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope.aliyuncs.com/api/v1'

messages = [
    {
        "role": "user",
        "content": [
            {"text": "一张充满秋日氛围的摄影图，画面中心是一片金黄的枫叶，叶脉清晰、边缘略带枯黄斑点，阳光从画面右侧洒下，形成耀眼的光斑与柔和的光线；背景是暖色调的树木（树叶呈橙红渐变），远处有朦胧的建筑轮廓；整体风格自然写实，光线明亮且带暖调，营造出宁静又诗意的秋日氛围，细节上突出枫叶的质感与光影层次。"}
        ]
    }
]

# 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
# 新加坡和北京地域的API Key不同。获取API Key：https://help.aliyun.com/zh/model-studio/get-api-key
api_key = "xxxxx"
for  i in range(0,5):
    response = MultiModalConversation.call(
        api_key=api_key,
        model="qwen-image-plus",
        messages=messages,
        result_format='message',
        stream=False,
        watermark=True,
        prompt_extend=True,
        negative_prompt='',
        size='1328*1328'
    )
    
    if response.status_code == 200:
        print(json.dumps(response, ensure_ascii=False))
        import requests
        url = json.dumps(response, ensure_ascii=False)
        reponse = requests.get(url=response.output.choices[0].message.content[0]['image'])
        with open('./ad50000'+str(i)+'.png','wb') as f:
            f.write(reponse.content)
    else:
        print(f"HTTP返回码：{response.status_code}")
        print(f"错误码：{response.code}")
        print(f"错误信息：{response.message}")
        print("请参考文档：https://help.aliyun.com/zh/model-studio/developer-reference/error-code")

# Python3.8以上
pip install pydantic==2.5.3 -i https://mirrors.aliyun.com/pypi/simple/
pip install  langchain-core==0.1.45 -i https://mirrors.aliyun.com/pypi/simple/
pip install langchain==0.1.16 -i https://mirrors.aliyun.com/pypi/simple/
pip install  dashscope==1.24.7 -i https://mirrors.aliyun.com/pypi/simple/

#导入库
import os
import pandas as pd
from typing import List, Optional
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.utils.function_calling import convert_to_openai_tool
from dashscope import Generation
import dashscope
from langchain.tools.render import render_text_description
import warnings
warnings.filterwarnings('ignore')

# 1.初始化大模型环境

# 使用大模型类型
os.environ["DASHSCOPE_API_KEY"] = "https://dashscope.aliyuncs.com/compatible-mode/v1"

dashscope.api_key = "xxx" // 阿里云百炼 https://bailian.console.aliyun.com/?tab=model#/api-key

from typing import Optional

from langchain_core.pydantic_v1 import BaseModel, Field


class Person(BaseModel):
    """Information about a person."""
    name: Optional[str] = Field(default=None, description="The name of the person")
    hair_color: Optional[str] = Field(default=None, description="The color of the peron's hair if known")
    height_in_meters: Optional[str] = Field(default=None, description="Height measured in meters")

2.读取数据

df=pd.read_excel(r"./原始数据.xlsx")

df.head(2)
df[df["Rating"]<2].groupby("Clothing_ID").size().sort_values().tail(10) # 评分低于2的最多的10条数据

3.筛选数据
re_862=df[(df["Rating"]<2)&(df["Clothing_ID"]==862)].Review_Text.dropna(axis=0,how=any).tolist() // 去掉Review_Text 缺省的数据

4.大模型处理

# 定义问题类别
class clothing(BaseModel):
    Fabric_problems: Optional[str] = Field(default=None, description="Fabric problems: noticeable holes, loose threads, pilling, or abnormal color fading and shrinkage")
    Workmanship_defects: Optional[str] = Field(default=None, description="Workmanship defects: poor stitching, excessive loose threads, easily detachable buttons, etc")
    Size_discrepancies : Optional[str] = Field(default=None, description="Size discrepancies: the actual product size differs from the described dimensions, leading to ill-fitting garments.")
    Uncomfortable_wear : Optional[str] = Field(default=None, description="non-breathable fabrics, irritation against the skin, or discomfort during wear.")
    Fit_design: Optional[str] = Field(default=None, description="Fit and design: unsuitable cut, not conforming to ergonomics, or unflattering when worn")
    Appearance_Discrepancies: Optional[str] = Field(default=None, description="Mismatch between the product received and online images in terms of style or color.")
    After_Sales: Optional[str] = Field(default=None, description="Unsatisfactory customer service attitude or response efficiency.")
    Value_Money: Optional[str] = Field(default=None, description="Consumers feel that the price does not align with the actual quality or value of the product, perceiving it as overpriced.")

class Data_yun(BaseModel):
    """提取负面信息"""
    comment: List[clothing]

# 封装请求数据
def prompt_yun(ct):
    system_prompt="您是提取算法专家。仅从文本中提取相关信息。如果您不知道要求提取的属性值，则为属性值返回 null。首先抽取出用户评价中的抱怨点，然后对这些点进行分类，然后调用工具输出"
    prompt=[{"content":system_prompt,"role":"system"},\
            {"role":"user","content":"The material is cheap"},\
            {'role': 'assistant', 'content': '', 'tool_calls_ids': [{'function': {'name': 'Data_yun', 'arguments': 
                                                                              '{"comment": [{"Fabric_problems": "The material is cheap","Size_discrepancies": "is made for women with long torso and shorter shoulders"}]}'}}]}]
    prompt.append({"role":"user","content":ct})
    return prompt

# 向大模型提问
def get_response_1t(mess):
    response = Generation.call(
        model='qwen-plus',
        messages=mess,
        tools=[convert_to_openai_tool(Data_yun)],
        result_format='message', # 将输出设置为message形式
    )
    return response

5.处理单个评论，进行模型能力测试

text = re_862[1]
p_y = prompt_yun(text)
res = get_response_1t(p_y)

res.output.choices[0].message["tool_calls"][0]['function']['arguments']


6.循环处理所有数据

import time
import numpy as np
for i in re_862:
    time.sleep(0)
    text = i
    if text is np.nan:
        print("数据为空值")
    else:
        p_y=prompt_yun(text)
        res=get_response_1t(p_y)
        print(res.output.choices[0].message["tool_calls"][0]['function']['arguments'])
        print('-'*20)

import pandas as pd
import warnings
warnings.filterwarnings("ignore")

1.读取数据

df = pd.read_csv('./fruit_purchases1.csv',sep=';')
df.head()

2.数据预处理

df_mtix = df['购买水果'].map(lambda line:line.replace(' ','').split(','))
或者
list_all_f  = []
for x in df['购买水果']：
 list_all_f.append(x.split(','))

from mlxtend.preprocessing import TransactionEncoder

model_te = TransactionEncoder()  # 设置参数
df_te = model_te.fit_transform(df_mtix)  # 应用到数据上
df_te = pd.DataFrame(data=df_te,columns=model_te.columns_)  # 转型

3.关联规则建模
from mlxtend.frequent_patterns import fpmax,fpgrowth,apriori // 不同的计算置信度的算法

model_apriori = apriori(df=df_te,min_support=0.2,use_colnames=True)
# model_fpmax = fpmax(df=df_te,min_support=0.1,use_colnames=True)
# model_fpgrowth = fpgrowth(df=df_te,min_support=0.1,use_colnames=True)

4.association_rules 函数来找出关联规则
from mlxtend.frequent_patterns import association_rules

rules = association_rules(df=model_apriori,metric='confidence',min_threshold=0.8)
rules

5. 推荐---当用户购买了某个水果后应推荐什么其他的水果

buyfruit = input('现已经买了什么水果')

lists = rules[rules['antecedents'] == {buyfruit}]['consequents'].values
print('用户购买了'+ buyfruit + '推荐', lists)

后续策略
去重
如果是一个任何关联都没有的水果，可以推荐support 最高的，购买次数最多的项集

<!-- 想要向某个用户去推荐音乐：
    计算处用户和哪些用户相似，在将和用户相似的用户听过的音乐，并且是用户没用听过的音乐，推荐给用户。
    张三：李四、王五   音乐：1 2 3 4 5 6
    李四：音乐：1  5  6  7  8 
    王五：音乐：2  4  7  9
    向张三推荐：7  8  9
1.计算用户之间的相似度：
2.相似的用户听过的音乐；
3.相似用户听过的音乐哪些是用户没有听过的的；
4.推荐 -->

# 导入pandas和numpy库
import pandas as pd
import numpy as np
# 读取数据集
user_artists = pd.read_csv('./music/user_artists.dat', sep='\t') # 优用"t'分隔符读取user artists.dat文件
artists = pd.read_csv('./music/artists.dat', sep='\t', usecols=['id', 'name']) # 使用t分隔符读取artists.dat文件，仅读取id和name列
user_artists

# 去除不必要的列
# user_artists = user_artists.drop(['weight'], axis=1)# 删除user _artists中的weight列

artists.head()

artists['id'] =artists['id'].astype(np.int64)

6.将user_artists和artists两个DataFrame进行合并，以user_artists中的artistID和artists中的id为键值进行连接。
# 合并数据集
data = pd.merge(user_artists, artists, left_on='artistID', right_on='id') # 将user_artists 和 artists 合并
data = data.drop(['id', 'artistID'], axis=1) # 删除data 中的id 和artistID 列
data

7.去除评分次数少于50次的音乐和用户。
counts = data['userID'].value_counts() # 计算每个用户的评分次数
data = data[data['userID'].isin(counts[counts >= 50].index)] # 去除评分次数少于50 次的用户

counts = data['name'].value_counts() # 计算每个音乐的评分次数
data = data[data['name'].isin(counts[counts >= 50].index)] # 去除评分次数少于50 次的音乐

# 将音乐和用户ID 转换为数字
name_to_index = {} # 创建 name_to_index 字典
index_to_name = {} # 创建index_to_name 字典
for i, name in enumerate(data['name'].unique()): # 遍历 data 中的name 列
    name_to_index[name] = i # 将name 映射到数字
    index_to_name[i] = name # 将数字映射到name
    
user_id_to_index = {} # 创建user_id_to_index 字典
index_to_user_id = {} # 创建index_to_user_id 字典
for i, user_id in enumerate(data['userID'].unique()): # 遍历data 中的userID 列
    user_id_to_index[user_id] = i # 将user_id 映射到数字
    index_to_user_id[i] = user_id # 将数字映射到user_id
data['name_index'] = data['name'].apply(lambda x: name_to_index[x]) # 将data 中的 name 映射到数字
data['user_index'] = data['userID'].apply(lambda x: user_id_to_index[x]) # 将data 中的 user_id 映射到数字
# # 构建用户-音乐评分矩阵
n_users = len(user_id_to_index) # 获取用户数量
n_artists = len(name_to_index) # 获取音乐数量
ratings_matrix = np.zeros((n_users, n_artists)) # 创建用户-音乐评分矩阵
ratings_matrix

8.将data中的评分填入用户-音乐评分矩阵，使得ratingsmatrix的输出为。
for row in data.itertuples(): # 遍历data
    ratings_matrix[row[5], row[4]] = row[2] # 将data 中的评分填入用户-音乐评分矩阵
    print(row)
ratings_matrix
#     print(row)
# 计算用户之间的相似度
from sklearn.metrics.pairwise import cosine_similarity # 导入sklearn 库中的余弦相似度计算函数
user_similarity = cosine_similarity(ratings_matrix) # 计算用户之间的相似度
# 为用户推荐音乐
user_index = 0 # 设置用户索引


9.获取与用户最相似的用户索引similar users(不包括自己)，使得similar users的输出为:
similar_users = np.argsort(-user_similarity[user_index])[1:] # 获取与用户索引为0 的用户最相似的用户索引
similar_users  
recommended_artists=[]# 创建推荐音乐列表

10.填补以下程序，获取相似用户评分的音乐索引artists_rated。

for i in similar_users: # 遍历相似用户索引
    artists_rated = np.where(ratings_matrix[i] > 0)[0] # 获取相似用户评分的音乐索引
    for j in artists_rated: # 遍历音乐索引
        if ratings_matrix[user_index][j] == 0: #用户未评分
            recommended_artists.append((j, ratings_matrix[i][j])) # 将音乐加入推荐音乐列表
recommended_artists = sorted(recommended_artists, key=lambda x: x[1], reverse=True)[:10] # 筛选出推荐音乐中的前10 首
for artist in recommended_artists: # 遍历推荐音乐
#     print(artists[artists['name'] == index_to_name[artist[0]]]['name'].values[0]) # 打印推荐音乐
    print(index_to_name.get(artist[0]))
#     print(artist)

artists[artists['name'] == index_to_name[artist[0]]]['name'].values[0]

pip install pandas
pip install numpy


df = pd.read_csv('./wine3.csv')
df.head()

df.isnull().sum()

df.shape # 查看行列数

del df['phenols'] # 删除列

df.shape

df.info() # 查看每列数据类型

<!-- np.nan 代表缺失值，可能是上面提到的三种 -->

# 填充
df['malic'] = df['malic'].replace(np.nan,df['malic'].mean()) 

# aixs : 0 按行删除； 
# how :any 只要有一个数据缺失就将该行删除，all 表示这一行全部缺失的时候才删除

df_drop = df.dropna(axis= 0, how='any') 

df_drop.isnull().sum()

import matplotlib.pyplot as plt
plt.boxplot(df_drop['malic'])
plt.show()

while True:
    list_error = []
    Q1 = df_drop['malic'].quantile(0.25)
    Q3 = df_drop['malic'].quantile(0.75)
    IQR = Q3 - Q1
    up = Q3 + 1.5*IQR
    down = Q1 - 1.5*IQR
    n = 0
    for x in df_drop['malic']:
        if x > up or x<down :
            print(x)
            df_drop.loc[:, 'malic'] = df_drop['malic'].replace(x,df_drop['malic'].mean()) # 填充 
            list_error.append(x)
    if len(list_error) == 0:
        break


for x in df_drop['malic']:
    if x > up or x<down :
        print(x)
plt.boxplot(df_drop['malic'])
plt.show()

mport  warnings
warnings.filterwarnings('ignore')

mean = df_drop['ash'].mean()
std = np.std(df_drop['ash'])
for x in df_drop['ash'].index:
    if np.abs(df_drop['ash'][x] - mean)>3*std:
        print(df_drop['ash'][x])
        df_drop.drop(axis=0,index=x,inplace=True)

# 纵向拆分
X= df_drop.drop(axis=1, columns='type')
Y = df_drop[['type']]

pip install scikit-learn

from sklearn.model_selection import train_test_split

X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.3)

from sklearn.neighbors import KNeighborsClassifier

model_knn = KNeighborsClassifier()
model_knn.fit(X_train, Y_train)

model_knn.score(X_test,Y_test)

pip install joblib

import joblib

joblib.dump(model_knn, './红酒等级预测.pkl')

import pandas as pd
import joblib

df = pd.read_csv('./wine3_pre.csv')
df.head()

model = joblib.load('./红酒等级预测.pkl')

<!-- 把要预测的数据处理成跟训练的时候的维度一样 -->
del df['phenols']
model.predict(df)

Y_pre = model.predict(df) # 预测
df['type'] = Y_pre # 合并数据

df.to_csv('./wine_model_pre.csv', index=False)

git clone https://github.com/hiyouga/LLaMA-Factory.git

cd LLaMA-Factory

pip install -e ".[torch,metrics]" 

# 如遇版本冲突可尝试用下面的命令

pip install --no-deps -e .
# 
llamafactory-cli version

# 方式一： 启动webui，通过页面配置进行微调
llamafactory-cli webui

# 方式二： 命令行进行微调 llamafactory-cli train 配置文件路径，文件和界面作用一样，只不过用key=value进行配置

llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml 

# 安装nvitop 查看内存使用情况

pip install nvitop
nvitop -m auto

# 方式一： 启动webui，通过页面配置进行微调
llamafactory-cli webui

# 方式二： 命令行进行微调 llamafactory-cli train 配置文件路径，文件和界面作用一样，只不过用key=value进行配置

llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

ollama show --modelfile Qwen2.5:0.5B

// 运行命令导出
llamafactory-cli export examples/merge_lora/llama3_lora_sft.yaml

// 查看模型相关信息，进一步确保模型正确导出

ollama show --modelfile Qwen2.5:0.5B

// 安装压缩命令行，对模型进行压缩
sudo add-apt-repository multiverse   
sudo apt update
sudo apt installsudo apt install unrar rar

// 把导出的模型进行压缩
rar a -r Qwen3-8rar a -r Qwen3-8B_lora_sft.rar ./output/Qwen3-8B_lora_sft/                                                        se

// 切换到导出模型的文件夹执行[部署]命令
ollama create qwen2.5-wt0.5b -f Modelfile
// 出现”success”表示模型部署成功。

open-webui server

pip install --upgrade pip -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
pip install pyautogen -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
pip install openai -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple

[
  {
    "model": "deepseek-r1:1.5b",
    "api_key": "testkey",
    "base_url": "http://localhost:11434/v1"
  }
]

# 角色
你是以为热情的医疗顾问，擅长根据患者的症状推荐合适的资料方案，还能与患者畅谈分享健康知识。让咨询过程充满关怀和专业。
## 技能
### 技能1：推荐治疗方案，直接给出患者一种治疗方案，如果不合适再询问患者具体症状。
1.当患者表明症状时，从已知治疗方案中挑选合适的进行推荐。
2.若不清楚患者症状时，可询问患者具体症状、病史等信息。
3.专注药物治疗推荐：
    -对于患者提出的非药物治疗问题（如手术或物理治疗），清始终引导回药物治疗推荐。
    -对于和药物治疗无关的问题，请忽略，请始终引导回药物治疗推荐。
只能出现这里面的治疗方案[
    {
    "名称": "酚麻美敏片",
    "主要成分": "对乙酰氨基酚、盐酸伪麻黄碱、氢溴酸右美沙芬、马来酸氯苯那敏",
    "适应症": "用于普通感冒或流行性感冒引起的发热、头痛、四肢酸痛、打喷嚏、流鼻涕、鼻塞、咳嗽、咽痛等症状",
    "剂量": "成人和12岁以上儿童，一次1 - 2片，每6小时服1次，24小时内不超过4次",
    "副作用": "有时有轻度头晕、乏力、恶心、上腹不适、口干、食欲缺乏和皮疹等，可自行恢复",
    "注意事项": "用药3 - 7天，症状未缓解，请咨询医师或药师；服用本品期间不得饮酒或含有酒精的饮料；不能同时服用与本品成份相似的其他抗感冒药等",
    "适用人群": "成人和12岁以上儿童",
    "使用时长": "一般不超过7天",
    "颜色": "薄膜衣片，除去包衣后显白色或类白色"
},
{
    "名称": "氢溴酸右美沙芬糖浆",
    "主要成分": "氢溴酸右美沙芬",
    "适应症": "用于干咳，包括上呼吸道感染（如感冒和咽炎）、支气管炎等引起的咳嗽",
    "剂量": "口服。成人一次10 - 20毫升，一日3 - 4次",
    "副作用": "可见头晕、头痛、嗜睡、易激动、嗳气、食欲缺乏、便秘、恶心、皮肤过敏等，但不影响疗效。停药后上述反应可自行消失",
    "注意事项": "用药7天，症状未缓解，请咨询医师；哮喘患者、痰多的患者、肝肾功能不全患者慎用；孕妇及哺乳期妇女慎用等",
    "适用人群": "成人",
    "使用时长": "一般不超过7天",
    "颜色": "棕黄色澄清液体"
},
{
    "名称": "氯雷他定片",
    "主要成分": "氯雷他定",
    "适应症": "用于缓解过敏性鼻炎有关的症状，如喷嚏、流涕、鼻痒、鼻塞以及眼部痒及烧灼感。口服药物后，鼻和眼部症状及体征得以迅速缓解。亦适用于缓解慢性荨麻疹、瘙痒性皮肤病及其他过敏性皮肤病的症状及体征",
    "剂量": "成人及12岁以上儿童：一日1次，一次1片（10毫克）；2 - 12岁儿童：体重＞30公斤：一日1次，一次1片（10毫克）；体重≤30公斤：一日1次，一次半片（5毫克）",
    "副作用": "常见不良反应有乏力、头痛、嗜睡、口干、胃肠道不适包括恶心、胃炎以及皮疹等。罕见不良反应有脱发、过敏反应、肝功能异常、心动过速及心悸等",
    "注意事项": "在做皮肤过敏试验前约48小时应中止使用本品；同时服用酮康唑、大环内酯类抗生素、西咪替丁、茶碱等药物，会提高氯雷他定在血浆中的浓度，应慎用；罕见不良反应有心动过速、心悸、肝酶升高、肝炎及胆红素增加等，应停药并就医等",
    "适用人群": "成人及2岁以上儿童",
    "使用时长": "根据病情而定，症状缓解后可停药，一般慢性疾病疗程较长",
    "颜色": "白色或类白色片"
},
{
    "名称": "健胃消食片",
    "主要成分": "太子参、陈皮、山药、麦芽（炒）、山楂",
    "适应症": "健胃消食。用于脾胃虚弱所致的食积，症见不思饮食、嗳腐酸臭、脘腹胀满；消化不良见上述证候者",
    "剂量": "口服，可以咀嚼。成人一次4 - 6片，儿童二岁至四岁一次2片，五岁至八岁一次3片，九岁至十四岁一次4片；一日3次",
    "副作用": "尚不明确",
    "注意事项": "饮食宜清淡，忌食辛辣、生冷、油腻食物；孕妇及哺乳期妇女慎用；儿童必须在成人监护下使用等",
    "适用人群": "各年龄段人群，儿童需在成人监护下使用",
    "使用时长": "症状缓解后即可停药",
    "颜色": "浅棕黄色的片；气微香，味微甜、酸"
},{
    "名称": "硝苯地平缓释片",
    "主要成分": "硝苯地平",
    "适应症": "各种类型的高血压及心绞痛",
    "剂量": "口服。一次10 - 20毫克，一日2次，极量，一次40毫克，一日0.12克",
    "副作用": "可能出现的副作用有外周水肿（外周水肿与剂量相关，服用120片/日时发生率为4.8%，服用240片/日则为12.8%）、头晕、头痛、脸红、心悸、乏力、恶心等",
    "注意事项": "低血压、严重主动脉瓣狭窄、肝肾功能不全患者慎用；用药期间定期监测血压和心率；避免突然停药，以免引起血压反跳等",
    "适用人群": "高血压及心绞痛患者",
    "使用时长": "需长期服用，根据血压控制情况调整剂量",
    "颜色": "黄色薄膜衣片除去薄膜衣后显黄色"
}
]

open-webui serve

pip install itsdangerous