import asyncio
import aiofiles
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def process_file(path: str):
    async with aiofiles.open(path) as f:
        content = await f.read()
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": f"用一句话总结：{content[:2000]}"}],
        max_tokens=50
    )
    return response.choices[0].message.content

async def main():
    import glob
    files = glob.glob("/data/inbox/*")
    tasks = [process_file(f) for f in files]
    results = await asyncio.gather(*tasks)
    for f, r in zip(files, results):
        print(f, r)

asyncio.run(main())

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "sync"
)

const (
    concurrency = 20
    apiKey      = "sk-..."
    model       = "gpt-4o-mini"
)

type ChatRequest struct {
    Model    string        `json:"model"`
    Messages []ChatMessage `json:"messages"`
    MaxTokens int          `json:"max_tokens"`
}

type ChatMessage struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

func callAI(prompt string) (string, error) {
    body := ChatRequest{
        Model:     model,
        Messages:  []ChatMessage{{Role: "user", Content: prompt}},
        MaxTokens: 50,
    }
    data, _ := json.Marshal(body)
    req, _ := http.NewRequest("POST", "https://api.openai.com/v1/chat/completions", bytes.NewReader(data))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    resBody, _ := io.ReadAll(resp.Body)
    var result map[string]interface{}
    json.Unmarshal(resBody, &result)
    choices := result["choices"].([]interface{})
    return choices[0].(map[string]interface{})["message"].(map[string]interface{})["content"].(string), nil
}

func worker(id int, jobs <-chan string, wg *sync.WaitGroup) {
    defer wg.Done()
    for path := range jobs {
        data, err := os.ReadFile(path)
        if err != nil {
            fmt.Fprintf(os.Stderr, "read %s: %v\n", path, err)
            continue
        }
        prompt := fmt.Sprintf("用一句话总结：%s", string(data)[:2000])
        summary, err := callAI(prompt)
        if err != nil {
            fmt.Fprintf(os.Stderr, "api %s: %v\n", path, err)
            continue
        }
        outPath := filepath.Join("/data/outbox", filepath.Base(path)+".summary")
        os.WriteFile(outPath, []byte(summary), 0644)
    }
}

func main() {
    pattern := "/data/inbox/*"
    files, _ := filepath.Glob(pattern)
    jobs := make(chan string, len(files))
    var wg sync.WaitGroup

    for i := 0; i < concurrency; i++ {
        wg.Add(1)
        go worker(i, jobs, &wg)
    }

    for _, f := range files {
        jobs <- f
    }
    close(jobs)
    wg.Wait()
}