代码1

from langchain.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain_core.output_parsers import StrOutputParser
import asyncio


class DeepSeekR1:
    def __init__(self):
        print("Loading DeepSeek-R1-Distill-Qwen-1.5B model via Ollama...")
        self.llm = ChatOllama(
            model="deepseek-r1:1.5b",
            temperature=0.7,
            base_url="http://localhost:11434"
        )

        self.prompt = ChatPromptTemplate.from_template("""
        你是一个友好的对话AI机器人。根据用户输入生成聪明得体的回复。

        用户输入: {input}

        请用1-10句话回复，保持自然友好的语气:
        """)

        self.chain = self.prompt | self.llm | StrOutputParser()

    def process_response(self, raw_response):
        reasoning_marker = "<think>"
        answer_marker = "</think>"
        reasoning_start = raw_response.find(reasoning_marker)
        answer_start = raw_response.find(answer_marker)

        if reasoning_start != -1 and answer_start != -1:
            reasoning = raw_response[reasoning_start + len(reasoning_marker):answer_start].strip()
            answer = raw_response[answer_start + len(answer_marker):].strip()
            return reasoning, answer
        else:
            return None, raw_response

    async def chat_async(self, prompt):
        print(f"Received prompt: {prompt}")
        raw_response = await self.chain.ainvoke({"input": prompt})

        reasoning, answer = self.process_response(raw_response)
        if reasoning:
            print(f"Generated thinking process: {reasoning}")
        print(f"Generated answer: {answer if answer else raw_response}")

        return {
            "answer": answer if answer else raw_response,
            "reasoning": reasoning if reasoning else None
        }

    def chat(self, prompt):
        # 同步调用异步方法
        return asyncio.run(self.chat_async(prompt))

    def generate_response_stream(self, prompt: str = ""):
        # 异步生成器实现流式输出
        async def generate_chunks():
            # 直接遍历每个token
            async for chunk in self.chain.astream({"input": prompt}):
                # 将每个chunk拆分成字符，然后逐个发送
                for char in chunk:
                    yield f"{char}"
                    await asyncio.sleep(0.01)  # 控制速度，避免输出太快

        return generate_chunks()


result = DeepSeekR1().chat("你好")
print(f"result: ",{result})

代码2

from langchain.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain_core.output_parsers import StrOutputParser
import asyncio


class Qwen2_7B:
    def __init__(self):
        print("Loading Qwen2-7B model via Ollama...")

        # 初始化Ollama聊天模型
        self.llm = ChatOllama(
            model="qwen2:7b",  # Ollama中的模型名称
            temperature=0.7,  # 控制生成随机性
            base_url="http://localhost:11434"  # Ollama服务地址
        )

        # 设置提示模板
        self.prompt = ChatPromptTemplate.from_template("""
        用户输入: {input}

        请根据上述输入生成合适的回复:
        """)

        # 创建处理链
        self.chain = self.prompt | self.llm | StrOutputParser()

    async def chat_async(self, prompt):
        """
        异步聊天方法
        """
        print(f"Received prompt: {prompt}")

        # 调用模型生成回复
        response = await self.chain.ainvoke({"input": prompt})
        print(f"Generated response: {response}")

        return response

    def chat(self, prompt):
        """
        同步聊天方法（包装异步方法）
        """
        return asyncio.run(self.chat_async(prompt))

    def generate_stream(self, prompt):
        """
        流式生成方法
        """

        async def stream_generator():
            async for chunk in self.chain.astream({"input": prompt}):
                yield chunk

        return stream_generator()