開發更AI的應用

async def get_response(self, user_input, thread_id=None):
    self.messages += [{"role": "user", "content": user_input}]
    response = self.client.chat.completions.create(
        model=self.model,
        messages=self.messages,
        temperature=0.7,
    )
    self.last_message = str(response.choices[0].message.content)
    return self.last_message

@agent_action
def get_current_weather(location, unit="fahrenheit"):
    """Get the current weather in a given location"""
    return f"""
    The current weather in {location} is 0 {unit}.
    """

@agent_action
def recommend(topic):
    """System:
    Provide a recommendation for a given {{topic}}.
    Use your best judgment to provide a recommendation. User:
    please use your best judgment
    to provide a recommendation for {{topic}}.
    """
    pass

{
  "type": "function",
  "function": {
    "name": "get_current_weather",
    "description": "Get the current weather in a given location",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "location"
        },
        "unit": {
          "type": "string",
          "enum": [
            "celsius",
            "fahrenheit"
          ]
        }
      },
      "required": [
        "location"
      ]
    }
  }
}

def get_response_stream(self, user_input, thread_id=None):
    self.last_message = ""
    self.messages += [{"role": "user", "content": user_input}]
    
    if self.tools and len(self.tools) > 0:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.messages,
            tools=self.tools,
            tool_choice="auto",
        )
    else:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.messages,
        )
        
    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls

if tool_calls:
    available_functions = {
        action["name"]: action["pointer"] for action in self.actions
    }
    self.messages.append(response_message)
    
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_to_call = available_functions[function_name]
        function_args = json.loads(tool_call.function.arguments)

        function_response = function_to_call(
            **function_args, _caller_agent=self
        )
        
        self.messages.append({
            "tool_call_id": tool_call.id,
            "role": "tool",
            "name": function_name,
            "content": str(function_response),
        })
        
    second_response = self.client.chat.completions.create(
        model=self.model,
        messages=self.messages,
    )
    
    response_message = second_response.choices[0].message

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# 1. 載入檔案
loader = PyPDFLoader("knowledge_document.pdf")
documents = loader.load()

# 2. 文字分割
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
)
chunks = text_splitter.split_documents(documents)

# 3. 建立嵌入和向量儲存
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# 定義提示範本
template = """使用以下上下文來回答問題。如果你不知道答案，就說你不知道，不要試圖編造答案。

上下文: {context}

問題: {question}
回答: """

PROMPT = PromptTemplate(
    template=template,
    input_variables=["context", "question"]
)

# 建立LLM
llm = ChatOpenAI(model_name="gpt-3.5-turbo")

# 構建RAG鏈
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    chain_type_kwargs={"prompt": PROMPT}
)

# 使用RAG鏈回答問題
response = qa_chain.run("什麼是向量資料函式庫的主要優勢?")
print(response)

# 對於結構化檔案(如學術論文)
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
    chunk_size=400,
    chunk_overlap=50,
    separators=["\n\n", "\n", " ", ""]
)

# 對於程式碼檔案
from langchain.text_splitter import Language
text_splitter = RecursiveCharacterTextSplitter.from_language(
    language=Language.PYTHON,
    chunk_size=700,
    chunk_overlap=50
)

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# 基本檢索器
basic_retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 8})

# LLM壓縮器
llm = ChatOpenAI(temperature=0)
compressor = LLMChainExtractor.from_llm(llm)

# 上下文壓縮檢索器
compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=basic_retriever
)

# 使用壓縮檢索器
compressed_docs = compression_retriever.get_relevant_documents("什麼是向量資料函式庫?")

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain.chains import ConversationChain

# 簡單緩衝記憶
buffer_memory = ConversationBufferMemory()

# 摘要記憶(適合長對話)
summary_memory = ConversationSummaryMemory(llm=ChatOpenAI())

# 將記憶應用到對話鏈
conversation = ConversationChain(
    llm=ChatOpenAI(),
    memory=summary_memory,
    verbose=True
)

# 進行對話
response = conversation.predict(input="我的名字是張小明")
print(response)

response = conversation.predict(input="你還記得我的名字嗎?")
print(response)

from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain

# 建立向量儲存
memory_vectorstore = Chroma(
    collection_name="memory",
    embedding_function=OpenAIEmbeddings()
)

# 建立記憶檢索器
retriever = memory_vectorstore.as_retriever(search_kwargs={"k": 5})
memory = VectorStoreRetrieverMemory(retriever=retriever)

# 增加一些初始記憶
memory.save_context(
    {"input": "我最喜歡的顏色是藍色"},
    {"output": "我會記住你喜歡藍色"}
)
memory.save_context(
    {"input": "我住在台北"},
    {"output": "瞭解，你住在台北"}
)

# 檢索相關記憶
print(memory.load_memory_variables({"prompt": "我喜歡什麼顏色?"}))

from nexus import Agent, Memory, Document
from nexus.memory import SemanticMemory

# 建立語義記憶例項
semantic_memory = SemanticMemory()

# 建立代理並設定記憶
agent = Agent(
    name="知識助手",
    llm="gpt-3.5-turbo",
    memory=semantic_memory,
    system_prompt="你是一個有記憶能力的助手，能記住使用者提供的訊息並在需要時回憶。"
)

# 增加記憶
semantic_memory.add("使用者資料", "使用者名是王小明，他喜歡籃球和電影。")

# 使用代理回答問題
response = agent.generate("我喜歡什麼運動?")
print(response)