import openai # 1.75.0
import json

def get_weather(location):
    """模拟天气查询函数"""
    return '{"Celsius": 27, "type": "sunny"}'

def main():
    client = openai.OpenAI(
        api_key="xxxxx",
        base_url="https://api.siliconflow.cn/v1"
    )
    
    # 定义可供调用的工具
    tools = [{
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名"
                    }
                },
                "required": ["city"],
            }
        }
    }]
    
    # 第一次请求：获取模型生成的函数调用指令
    res = client.chat.completions.create(
        model="Qwen/Qwen2.5-32B-Instruct",
        messages=[
            {"role": "system", "content": "你是一个天气查询助手"},
            {"role": "user", "content": "帮我查询上海的天气"}
        ],
        tools=tools,
        tool_choice="auto"
    )
    
    print("第一次响应:", res.choices[0].message.to_dict())
    
    # 准备二次请求的上下文
    messages = [
        {"role": "system", "content": "你是一个天气查询助手"},
        {"role": "user", "content": "帮我查询上海的天气"},
        res.choices[0].message.to_dict()  # 加入第一次的模型响应
    ]
    
    # 执行函数调用
    tool_call = res.choices[0].message.tool_calls[0]
    arguments = json.loads(tool_call.function.arguments)
    messages.append({
        "role": "tool",
        "content": get_weather(arguments['city']),
        "tool_call_id": tool_call.id
    })
    
    # 第二次请求：让模型处理函数返回结果
    res = client.chat.completions.create(
        model="Qwen/Qwen2.5-32B-Instruct",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )
    
    print("最终响应:", res.choices[0].message.content)

if __name__ == "__main__":
    main()

import com.theokanning.openai.client.OpenAiApi;
import com.theokanning.openai.service.OpenAiService;
import com.theokanning.openai.completion.chat.*;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.jackson.JacksonConverterFactory;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

public class FunctionCallingExample {
    
    public static String getWeather(String location) {
        // 模拟天气查询
        return "{\"temperature\": 27, \"condition\": \"sunny\"}";
    }

    public static void main(String[] args) {
        // 初始化OpenAI服务
        OpenAiService service = new OpenAiService("your-api-key", Duration.ofSeconds(30));
        
        // 定义工具列表
        List<ChatTool> tools = new ArrayList<>();
        ChatFunction function = ChatFunction.builder()
                .name("get_weather")
                .description("获取指定城市的天气")
                .executor(arguments -> getWeather(arguments.get("city").asText())) // 实际执行函数
                .build();
        tools.add(ChatTool.builder().function(function).build());
        
        // 构建聊天消息
        List<ChatMessage> messages = new ArrayList<>();
        messages.add(new ChatMessage(ChatMessageRole.SYSTEM.value(), "你是一个天气查询助手"));
        messages.add(new ChatMessage(ChatMessageRole.USER.value(), "帮我查询上海的天气"));
        
        // 第一次请求：获取函数调用指令
        ChatCompletionRequest chatRequest = ChatCompletionRequest.builder()
                .model("gpt-4")
                .messages(messages)
                .tools(tools)
                .build();
        
        ChatCompletionResult result = service.createChatCompletion(chatRequest);
        System.out.println("第一次响应: " + result.getChoices().get(0).getMessage());
        
        // 准备第二次请求的上下文
        messages.add(result.getChoices().get(0).getMessage());
        
        // 执行函数调用并添加结果到上下文
        ChatMessage assistantMessage = result.getChoices().get(0).getMessage();
        if (assistantMessage.getToolCalls() != null && !assistantMessage.getToolCalls().isEmpty()) {
            ChatToolCall toolCall = assistantMessage.getToolCalls().get(0);
            String functionResult = getWeather(toolCall.getFunction().getArguments());
            
            messages.add(new ChatMessage(
                ChatMessageRole.TOOL.value(),
                functionResult,
                toolCall.getId()
            ));
        }
        
        // 第二次请求：获取最终回答
        chatRequest = ChatCompletionRequest.builder()
                .model("gpt-4")
                .messages(messages)
                .tools(tools)
                .build();
        
        result = service.createChatCompletion(chatRequest);
        System.out.println("最终响应: " + result.getChoices().get(0).getMessage().getContent());
    }
}

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI

# 1. 加载文档
loader = WebBaseLoader(["https://example.com/ai-article"])
documents = loader.load()

# 2. 文档分块
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# 3. 创建向量存储
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
db = FAISS.from_documents(texts, embeddings)

# 4. 创建RAG链
retriever = db.as_retriever(search_kwargs={"k": 3})
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(temperature=0),
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# 5. 提问
query = "什么是RAG技术？"
result = qa_chain({"query": query})

print("答案:", result["result"])
print("来源:", result["source_documents"])

import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.chat.messages.UserMessage;

import java.util.List;
import java.util.Map;

public class RagExample {
    
    private final EmbeddingClient embeddingClient;
    private final OpenAiChatClient chatClient;
    private VectorStore vectorStore;
    
    public RagExample(EmbeddingClient embeddingClient, OpenAiChatClient chatClient) {
        this.embeddingClient = embeddingClient;
        this.chatClient = chatClient;
        initializeVectorStore();
    }
    
    private void initializeVectorStore() {
        // 初始化向量存储
        vectorStore = new SimpleVectorStore(embeddingClient);
        
        // 添加示例文档（实际应用中可以从文件或数据库加载）
        vectorStore.add(List.of(
            new Document("RAG(检索增强生成)是一种结合检索和生成的技术...", 
                Map.of("source", "AI技术手册")),
            new Document("RAG系统通常包含检索和生成两个阶段...", 
                Map.of("source", "技术白皮书"))
        ));
    }
    
    public String query(String question) {
        // 检索相关文档
        List<Document> docs = vectorStore.similaritySearch(question);
        
        // 构建系统提示
        SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate("""
            你是一个AI助手，请基于以下上下文回答问题：
            {context}
            
            如果上下文不包含答案，请回答"我不知道"。""");
        
        // 合并检索到的文档作为上下文
        String context = docs.stream()
            .map(Document::getContent)
            .reduce("", (a, b) -> a + "\n\n" + b);
        
        // 创建提示
        Prompt prompt = new Prompt(List.of(
            systemPromptTemplate.createMessage(Map.of("context", context)),
            new UserMessage(question)
        ));
        
        // 获取AI响应
        ChatResponse response = chatClient.call(prompt);
        return response.getResult().getOutput().getContent();
    }
    
    public static void main(String[] args) {
        // 实际应用中可以通过Spring依赖注入获取这些bean
        EmbeddingClient embeddingClient = new OpenAiEmbeddingClient("your-api-key");
        OpenAiChatClient chatClient = new OpenAiChatClient("your-api-key");
        
        RagExample rag = new RagExample(embeddingClient, chatClient);
        String answer = rag.query("什么是RAG技术？");
        System.out.println("答案: " + answer);
    }
}

// 配置MCP客户端
@Bean
public McpClient mcpClient() {
    return McpClient.builder()
            .serverUrl("https://mcp.example.com")
            .credentials("api-key")
            .build();
}

// 定义AI服务
@Service
public class AIService {
    
    private final ChatClient chatClient;
    private final McpClient mcpClient;
    
    public AIService(ChatClient chatClient, McpClient mcpClient) {
        this.chatClient = chatClient;
        this.mcpClient = mcpClient;
    }
    
    public String handleQuery(String userQuery) {
        // 通过MCP获取相关上下文
        McpResponse context = mcpClient.retrieve()
                .query(userQuery)
                .execute();
        
        // 构建增强提示
        Prompt prompt = new Prompt(
            "你是一个智能助手，请基于以下上下文回答问题：\n" +
            context.getContent() + "\n\n问题：" + userQuery
        );
        
        // 获取AI生成
        return chatClient.call(prompt).getResult();
    }
}

import org.springframework.ai.mcp.McpClient;
import org.springframework.ai.mcp.McpResponse;
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.stereotype.Service;

@Service
public class McpIntegrationService {
    
    private final ChatClient chatClient;
    private final McpClient mcpClient;
    
    public McpIntegrationService(ChatClient chatClient, McpClient mcpClient) {
        this.chatClient = chatClient;
        this.mcpClient = mcpClient;
    }
    
    public String processQuery(String userQuery) {
        // 通过MCP获取上下文
        McpResponse context = mcpClient.retrieve()
                .query(userQuery)
                .execute();
        
        // 构建增强提示
        Prompt prompt = new Prompt(
            "你是一个智能助手，请基于以下上下文回答问题：\n" +
            context.getContent() + "\n\n问题：" + userQuery
        );
        
        // 获取AI生成
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }
    
    // 配置类示例
    @Configuration
    public static class McpConfig {
        
        @Bean
        public McpClient mcpClient() {
            return McpClient.builder()
                    .serverUrl("https://mcp.example.com")
                    .apiKey("your-mcp-api-key")
                    .build();
        }
    }
}