From b9ada3d1bbeba95bcbaef93770f13308430496a7 Mon Sep 17 00:00:00 2001 From: Richard Anthony Hein Date: Tue, 13 Aug 2024 21:23:42 +0000 Subject: [PATCH] Added FastAPI server for Chatbot API --- swarms/server/callback_handlers.py | 448 ++++++++++++++++++++ swarms/server/responses.py | 179 ++++++++ swarms/server/responses/server_responses.py | 69 +++ swarms/server/server.py | 445 +++++++++++++++++++ swarms/server/server_models.py | 88 ++++ swarms/server/server_prompts.py | 78 ++++ swarms/server/static/favicon.ico | Bin 0 -> 149514 bytes swarms/server/utils.py | 51 +++ 8 files changed, 1358 insertions(+) create mode 100644 swarms/server/callback_handlers.py create mode 100644 swarms/server/responses.py create mode 100644 swarms/server/responses/server_responses.py create mode 100644 swarms/server/server.py create mode 100644 swarms/server/server_models.py create mode 100644 swarms/server/server_prompts.py create mode 100644 swarms/server/static/favicon.ico create mode 100644 swarms/server/utils.py diff --git a/swarms/server/callback_handlers.py b/swarms/server/callback_handlers.py new file mode 100644 index 00000000..710b64d7 --- /dev/null +++ b/swarms/server/callback_handlers.py @@ -0,0 +1,448 @@ +# modified from Lanarky sourcecode https://github.com/auxon/lanarky +from typing import Any, Optional + +from fastapi.websockets import WebSocket +from langchain.callbacks.base import AsyncCallbackHandler +from langchain.callbacks.streaming_stdout_final_only import ( + FinalStreamingStdOutCallbackHandler, +) +from langchain.globals import get_llm_cache +from langchain.schema.document import Document +from pydantic import BaseModel +from starlette.types import Message, Send +from sse_starlette.sse import ensure_bytes, ServerSentEvent +from swarms.server.utils import StrEnum, model_dump_json + + +class LangchainEvents(StrEnum): + SOURCE_DOCUMENTS = "source_documents" + + +class BaseCallbackHandler(AsyncCallbackHandler): + """Base callback handler for streaming / async applications.""" + + def __init__(self, **kwargs: dict[str, Any]) -> None: + super().__init__(**kwargs) + self.llm_cache_used = get_llm_cache() is not None + + @property + def always_verbose(self) -> bool: + """Verbose mode is always enabled.""" + return True + + async def on_chat_model_start(self, *args: Any, **kwargs: Any) -> Any: ... + + +class StreamingCallbackHandler(BaseCallbackHandler): + """Callback handler for streaming responses.""" + + def __init__( + self, + *, + send: Send = None, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + send: The ASGI send callable. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(**kwargs) + + self._send = send + self.streaming = None + + @property + def send(self) -> Send: + return self._send + + @send.setter + def send(self, value: Send) -> None: + """Setter method for send property.""" + if not callable(value): + raise ValueError("value must be a Callable") + self._send = value + + def _construct_message(self, data: str, event: Optional[str] = None) -> Message: + """Constructs message payload. + + Args: + data: The data payload. + event: The event name. + """ + chunk = ServerSentEvent(data=data, event=event) + return { + "type": "http.response.body", + "body": ensure_bytes(chunk, None), + "more_body": True, + } + + +class TokenStreamMode(StrEnum): + TEXT = "text" + JSON = "json" + + +class TokenEventData(BaseModel): + """Event data payload for tokens.""" + + token: str = "" + + +def get_token_data(token: str, mode: TokenStreamMode) -> str: + """Get token data based on mode. + + Args: + token: The token to use. + mode: The stream mode. + """ + if mode not in list(TokenStreamMode): + raise ValueError(f"Invalid stream mode: {mode}") + + if mode == TokenStreamMode.TEXT: + return token + else: + return model_dump_json(TokenEventData(token=token)) + + +class TokenStreamingCallbackHandler(StreamingCallbackHandler): + """Callback handler for streaming tokens.""" + + def __init__( + self, + *, + output_key: str, + mode: TokenStreamMode = TokenStreamMode.JSON, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + output_key: chain output key. + mode: The stream mode. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(**kwargs) + + self.output_key = output_key + + if mode not in list(TokenStreamMode): + raise ValueError(f"Invalid stream mode: {mode}") + self.mode = mode + + async def on_chain_start(self, *args: Any, **kwargs: dict[str, Any]) -> None: + """Run when chain starts running.""" + self.streaming = False + + async def on_llm_new_token(self, token: str, **kwargs: dict[str, Any]) -> None: + """Run on new LLM token. Only available when streaming is enabled.""" + if not self.streaming: + self.streaming = True + + if self.llm_cache_used: # cache missed (or was never enabled) if we are here + self.llm_cache_used = False + + message = self._construct_message( + data=get_token_data(token, self.mode), event="completion" + ) + await self.send(message) + + async def on_chain_end( + self, outputs: dict[str, Any], **kwargs: dict[str, Any] + ) -> None: + """Run when chain ends running. + + Final output is streamed only if LLM cache is enabled. + """ + if self.llm_cache_used or not self.streaming: + if self.output_key in outputs: + message = self._construct_message( + data=get_token_data(outputs[self.output_key], self.mode), + event="completion", + ) + await self.send(message) + else: + raise KeyError(f"missing outputs key: {self.output_key}") + + +class SourceDocumentsEventData(BaseModel): + """Event data payload for source documents.""" + + source_documents: list[dict[str, Any]] + + +class SourceDocumentsStreamingCallbackHandler(StreamingCallbackHandler): + """Callback handler for streaming source documents.""" + + async def on_chain_end( + self, outputs: dict[str, Any], **kwargs: dict[str, Any] + ) -> None: + """Run when chain ends running.""" + if "source_documents" in outputs: + if not isinstance(outputs["source_documents"], list): + raise ValueError("source_documents must be a list") + if not isinstance(outputs["source_documents"][0], Document): + raise ValueError("source_documents must be a list of Document") + + # NOTE: langchain is using pydantic_v1 for `Document` + source_documents: list[dict] = [ + document.dict() for document in outputs["source_documents"] + ] + message = self._construct_message( + data=model_dump_json( + SourceDocumentsEventData(source_documents=source_documents) + ), + event=LangchainEvents.SOURCE_DOCUMENTS, + ) + await self.send(message) + + +class FinalTokenStreamingCallbackHandler( + TokenStreamingCallbackHandler, FinalStreamingStdOutCallbackHandler +): + """Callback handler for streaming final answer tokens. + + Useful for streaming responses from Langchain Agents. + """ + + def __init__( + self, + *, + answer_prefix_tokens: Optional[list[str]] = None, + strip_tokens: bool = True, + stream_prefix: bool = False, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + answer_prefix_tokens: The answer prefix tokens to use. + strip_tokens: Whether to strip tokens. + stream_prefix: Whether to stream the answer prefix. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(output_key=None, **kwargs) + + FinalStreamingStdOutCallbackHandler.__init__( + self, + answer_prefix_tokens=answer_prefix_tokens, + strip_tokens=strip_tokens, + stream_prefix=stream_prefix, + ) + + async def on_llm_start(self, *args: Any, **kwargs: dict[str, Any]) -> None: + """Run when LLM starts running.""" + self.answer_reached = False + self.streaming = False + + async def on_llm_new_token(self, token: str, **kwargs: dict[str, Any]) -> None: + """Run on new LLM token. Only available when streaming is enabled.""" + if not self.streaming: + self.streaming = True + + # Remember the last n tokens, where n = len(answer_prefix_tokens) + self.append_to_last_tokens(token) + + # Check if the last n tokens match the answer_prefix_tokens list ... + if self.check_if_answer_reached(): + self.answer_reached = True + if self.stream_prefix: + message = self._construct_message( + data=get_token_data("".join(self.last_tokens), self.mode), + event="completion", + ) + await self.send(message) + + # ... if yes, then print tokens from now on + if self.answer_reached: + message = self._construct_message( + data=get_token_data(token, self.mode), event="completion" + ) + await self.send(message) + + +class WebSocketCallbackHandler(BaseCallbackHandler): + """Callback handler for websocket sessions.""" + + def __init__( + self, + *, + mode: TokenStreamMode = TokenStreamMode.JSON, + websocket: WebSocket = None, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + mode: The stream mode. + websocket: The websocket to use. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(**kwargs) + + if mode not in list(TokenStreamMode): + raise ValueError(f"Invalid stream mode: {mode}") + self.mode = mode + + self._websocket = websocket + self.streaming = None + + @property + def websocket(self) -> WebSocket: + return self._websocket + + @websocket.setter + def websocket(self, value: WebSocket) -> None: + """Setter method for send property.""" + if not isinstance(value, WebSocket): + raise ValueError("value must be a WebSocket") + self._websocket = value + + def _construct_message(self, data: str, event: Optional[str] = None) -> Message: + """Constructs message payload. + + Args: + data: The data payload. + event: The event name. + """ + return dict(data=data, event=event) + + +class TokenWebSocketCallbackHandler(WebSocketCallbackHandler): + """Callback handler for sending tokens in websocket sessions.""" + + def __init__(self, *, output_key: str, **kwargs: dict[str, Any]) -> None: + """Constructor method. + + Args: + output_key: chain output key. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(**kwargs) + + self.output_key = output_key + + async def on_chain_start(self, *args: Any, **kwargs: dict[str, Any]) -> None: + """Run when chain starts running.""" + self.streaming = False + + async def on_llm_new_token(self, token: str, **kwargs: dict[str, Any]) -> None: + """Run on new LLM token. Only available when streaming is enabled.""" + if not self.streaming: + self.streaming = True + + if self.llm_cache_used: # cache missed (or was never enabled) if we are here + self.llm_cache_used = False + + message = self._construct_message( + data=get_token_data(token, self.mode), event="completion" + ) + await self.websocket.send_json(message) + + async def on_chain_end( + self, outputs: dict[str, Any], **kwargs: dict[str, Any] + ) -> None: + """Run when chain ends running. + + Final output is streamed only if LLM cache is enabled. + """ + if self.llm_cache_used or not self.streaming: + if self.output_key in outputs: + message = self._construct_message( + data=get_token_data(outputs[self.output_key], self.mode), + event="completion", + ) + await self.websocket.send_json(message) + else: + raise KeyError(f"missing outputs key: {self.output_key}") + + +class SourceDocumentsWebSocketCallbackHandler(WebSocketCallbackHandler): + """Callback handler for sending source documents in websocket sessions.""" + + async def on_chain_end( + self, outputs: dict[str, Any], **kwargs: dict[str, Any] + ) -> None: + """Run when chain ends running.""" + if "source_documents" in outputs: + if not isinstance(outputs["source_documents"], list): + raise ValueError("source_documents must be a list") + if not isinstance(outputs["source_documents"][0], Document): + raise ValueError("source_documents must be a list of Document") + + # NOTE: langchain is using pydantic_v1 for `Document` + source_documents: list[dict] = [ + document.dict() for document in outputs["source_documents"] + ] + message = self._construct_message( + data=model_dump_json( + SourceDocumentsEventData(source_documents=source_documents) + ), + event=LangchainEvents.SOURCE_DOCUMENTS, + ) + await self.websocket.send_json(message) + + +class FinalTokenWebSocketCallbackHandler( + TokenWebSocketCallbackHandler, FinalStreamingStdOutCallbackHandler +): + """Callback handler for sending final answer tokens in websocket sessions. + + Useful for streaming responses from Langchain Agents. + """ + + def __init__( + self, + *, + answer_prefix_tokens: Optional[list[str]] = None, + strip_tokens: bool = True, + stream_prefix: bool = False, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + answer_prefix_tokens: The answer prefix tokens to use. + strip_tokens: Whether to strip tokens. + stream_prefix: Whether to stream the answer prefix. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(output_key=None, **kwargs) + + FinalStreamingStdOutCallbackHandler.__init__( + self, + answer_prefix_tokens=answer_prefix_tokens, + strip_tokens=strip_tokens, + stream_prefix=stream_prefix, + ) + + async def on_llm_start(self, *args, **kwargs) -> None: + """Run when LLM starts running.""" + self.answer_reached = False + self.streaming = False + + async def on_llm_new_token(self, token: str, **kwargs: dict[str, Any]) -> None: + """Run on new LLM token. Only available when streaming is enabled.""" + if not self.streaming: + self.streaming = True + + # Remember the last n tokens, where n = len(answer_prefix_tokens) + self.append_to_last_tokens(token) + + # Check if the last n tokens match the answer_prefix_tokens list ... + if self.check_if_answer_reached(): + self.answer_reached = True + if self.stream_prefix: + message = self._construct_message( + data=get_token_data("".join(self.last_tokens), self.mode), + event="completion", + ) + await self.websocket.send_json(message) + + # ... if yes, then print tokens from now on + if self.answer_reached: + message = self._construct_message( + data=get_token_data(token, self.mode), event="completion" + ) + await self.websocket.send_json(message) \ No newline at end of file diff --git a/swarms/server/responses.py b/swarms/server/responses.py new file mode 100644 index 00000000..fab90a40 --- /dev/null +++ b/swarms/server/responses.py @@ -0,0 +1,179 @@ +from typing import Any +import asyncio +from functools import partial +from typing import Any + +from fastapi import status +from langchain.chains.base import Chain +from starlette.types import Send +from fastapi import status +from sse_starlette import ServerSentEvent +from sse_starlette.sse import EventSourceResponse +from starlette.types import Send + +from swarms.server.utils import StrEnum + +from sse_starlette.sse import ensure_bytes + + +class HTTPStatusDetail(StrEnum): + INTERNAL_SERVER_ERROR = "Internal Server Error" + + +class StreamingResponse(EventSourceResponse): + """`Response` class for streaming server-sent events. + + Follows the + [EventSource protocol](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events#interfaces) + """ + + def __init__( + self, + content: Any = iter(()), + *args: Any, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + content: The content to stream. + """ + super().__init__(content=content, *args, **kwargs) + + async def stream_response(self, send: Send) -> None: + """Streams data chunks to client by iterating over `content`. + + If an exception occurs while iterating over `content`, an + internal server error is sent to the client. + + Args: + send: The send function from the ASGI framework. + """ + await send( + { + "type": "http.response.start", + "status": self.status_code, + "headers": self.raw_headers, + } + ) + + try: + async for data in self.body_iterator: + chunk = ensure_bytes(data, self.sep) + print(f"chunk: {chunk.decode()}") + await send( + {"type": "http.response.body", "body": chunk, "more_body": True} + ) + except Exception as e: + print(f"body iterator error: {e}") + chunk = ServerSentEvent( + data=dict( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=HTTPStatusDetail.INTERNAL_SERVER_ERROR, + ), + event="error", + ) + await send( + { + "type": "http.response.body", + "body": ensure_bytes(chunk, None), + "more_body": True, + } + ) + + await send({"type": "http.response.body", "body": b"", "more_body": False}) + + + +class ChainRunMode(StrEnum): + """Enum for LangChain run modes.""" + + ASYNC = "async" + SYNC = "sync" + + +class LangchainStreamingResponse(StreamingResponse): + """StreamingResponse class for LangChain resources.""" + + def __init__( + self, + chain: Chain, + config: dict[str, Any], + run_mode: ChainRunMode = ChainRunMode.ASYNC, + *args: Any, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + chain: A LangChain instance. + config: A config dict. + *args: Positional arguments to pass to the parent constructor. + **kwargs: Keyword arguments to pass to the parent constructor. + """ + super().__init__(*args, **kwargs) + + self.chain = chain + self.config = config + + if run_mode not in list(ChainRunMode): + raise ValueError( + f"Invalid run mode '{run_mode}'. Must be one of {list(ChainRunMode)}" + ) + + self.run_mode = run_mode + + async def stream_response(self, send: Send) -> None: + """Stream LangChain outputs. + + If an exception occurs while iterating over the LangChain, an + internal server error is sent to the client. + + Args: + send: The ASGI send callable. + """ + await send( + { + "type": "http.response.start", + "status": self.status_code, + "headers": self.raw_headers, + } + ) + + if "callbacks" in self.config: + for callback in self.config["callbacks"]: + if hasattr(callback, "send"): + callback.send = send + + try: + # TODO: migrate to `.ainvoke` when adding support + # for LCEL + if self.run_mode == ChainRunMode.ASYNC: + outputs = await self.chain.acall(**self.config) + else: + loop = asyncio.get_event_loop() + outputs = await loop.run_in_executor( + None, partial(self.chain, **self.config) + ) + if self.background is not None: + self.background.kwargs.update({"outputs": outputs}) + except Exception as e: + print(f"chain runtime error: {e}") + if self.background is not None: + self.background.kwargs.update({"outputs": {}, "error": e}) + chunk = ServerSentEvent( + data=dict( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=HTTPStatusDetail.INTERNAL_SERVER_ERROR, + ), + event="error", + ) + await send( + { + "type": "http.response.body", + "body": ensure_bytes(chunk, None), + "more_body": True, + } + ) + + await send({"type": "http.response.body", "body": b"", "more_body": False}) \ No newline at end of file diff --git a/swarms/server/responses/server_responses.py b/swarms/server/responses/server_responses.py new file mode 100644 index 00000000..adf9cb88 --- /dev/null +++ b/swarms/server/responses/server_responses.py @@ -0,0 +1,69 @@ +from typing import Any +from fastapi import status +from starlette.types import Send +from sse_starlette.sse import ensure_bytes, EventSourceResponse, ServerSentEvent + +class StreamingResponse(EventSourceResponse): + """`Response` class for streaming server-sent events. + + Follows the + [EventSource protocol](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events#interfaces) + """ + + def __init__( + self, + content: Any = iter(()), + *args: Any, + **kwargs: dict[str, Any], + ) -> None: + """Constructor method. + + Args: + content: The content to stream. + """ + super().__init__(content=content, *args, **kwargs) + + async def stream_response(self, send: Send) -> None: + """Streams data chunks to client by iterating over `content`. + + If an exception occurs while iterating over `content`, an + internal server error is sent to the client. + + Args: + send: The send function from the ASGI framework. + """ + await send( + { + "type": "http.response.start", + "status": self.status_code, + "headers": self.raw_headers, + } + ) + + try: + async for data in self.body_iterator: + chunk = ensure_bytes(data, self.sep) + with open("log.txt", "a") as log_file: + log_file.write(f"chunk: {chunk.decode()}\n") + await send( + {"type": "http.response.body", "body": chunk, "more_body": True} + ) + except Exception as e: + with open("log.txt", "a") as log_file: + log_file.write(f"body iterator error: {e}\n") + chunk = ServerSentEvent( + data=dict( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="Internal Server Error", + ), + event="error", + ) + await send( + { + "type": "http.response.body", + "body": ensure_bytes(chunk, None), + "more_body": True, + } + ) + + await send({"type": "http.response.body", "body": b"", "more_body": False}) \ No newline at end of file diff --git a/swarms/server/server.py b/swarms/server/server.py new file mode 100644 index 00000000..3f759a98 --- /dev/null +++ b/swarms/server/server.py @@ -0,0 +1,445 @@ +import asyncio +import json +import logging +import os +from datetime import datetime +from typing import List + +import langchain +from pydantic import ValidationError, parse_obj_as +from swarms.prompts.chat_prompt import Message, Role +from swarms.server.callback_handlers import SourceDocumentsStreamingCallbackHandler, TokenStreamingCallbackHandler +import tiktoken + +# import torch +from dotenv import load_dotenv +from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile +from fastapi.middleware.cors import CORSMiddleware +from fastapi.responses import FileResponse, JSONResponse +from fastapi.routing import APIRouter +from fastapi.staticfiles import StaticFiles +from huggingface_hub import login +from langchain.callbacks import StreamingStdOutCallbackHandler +from langchain.memory import ConversationSummaryBufferMemory +from langchain.memory.chat_message_histories.in_memory import ChatMessageHistory +from langchain.prompts.prompt import PromptTemplate +from langchain_community.chat_models import ChatOpenAI +from swarms.server.responses import LangchainStreamingResponse +from langchain.chains.conversational_retrieval.base import ConversationalRetrievalChain +from langchain.chains.llm import LLMChain +from langchain.chains.combine_documents.stuff import StuffDocumentsChain +from swarms.prompts.conversational_RAG import ( + B_INST, + B_SYS, + CONDENSE_PROMPT_TEMPLATE, + DOCUMENT_PROMPT_TEMPLATE, + E_INST, + E_SYS, + QA_PROMPT_TEMPLATE, + SUMMARY_PROMPT_TEMPLATE, +) + +from swarms.server.vector_store import VectorStorage + +from swarms.server.server_models import ( + ChatRequest, + LogMessage, + AIModel, + AIModels, + RAGFile, + RAGFiles, + State, + GetRAGFileStateRequest, + ProcessRAGFileRequest +) + +# Explicitly specify the path to the .env file +dotenv_path = os.path.join(os.path.dirname(__file__), '.env') +load_dotenv(dotenv_path) + +hf_token = os.environ.get("HUGGINFACEHUB_API_KEY") # Get the Huggingface API Token +uploads = os.environ.get("UPLOADS") # Directory where user uploads files to be parsed for RAG +model_dir = os.environ.get("MODEL_DIR") + +# hugginface.co model (eg. meta-llama/Llama-2-70b-hf) +model_name = os.environ.get("MODEL_NAME") + +# Set OpenAI's API key to 'EMPTY' and API base URL to use vLLM's API server, or set them to OpenAI API key and base URL. +openai_api_key = os.environ.get("OPENAI_API_KEY") or "EMPTY" +openai_api_base = os.environ.get("OPENAI_API_BASE") or "http://localhost:8000/v1" + +env_vars = [ + hf_token, + uploads, + model_dir, + model_name, + openai_api_key, + openai_api_base, +] +missing_vars = [var for var in env_vars if not var] + +if missing_vars: + print( + f"Error: The following environment variables are not set: {', '.join(missing_vars)}" + ) + exit(1) + +useMetal = os.environ.get("USE_METAL", "False") == "True" + +print(f"Uploads={uploads}") +print(f"MODEL_DIR={model_dir}") +print(f"MODEL_NAME={model_name}") +print(f"USE_METAL={useMetal}") +print(f"OPENAI_API_KEY={openai_api_key}") +print(f"OPENAI_API_BASE={openai_api_base}") + +# update tiktoken to include the model name (avoids warning message) +tiktoken.model.MODEL_TO_ENCODING.update( + { + model_name: "cl100k_base", + } +) + +print("Logging in to huggingface.co...") +login(token=hf_token) # login to huggingface.co + +# langchain.debug = True +langchain.verbose = True + +from contextlib import asynccontextmanager + +@asynccontextmanager +async def lifespan(app: FastAPI): + asyncio.create_task(vector_store.initRetrievers()) + yield + +app = FastAPI(title="Chatbot", lifespan=lifespan) +router = APIRouter() + +current_dir = os.path.dirname(__file__) +print("current_dir: " + current_dir) +static_dir = os.path.join(current_dir, "static") +print("static_dir: " + static_dir) +app.mount(static_dir, StaticFiles(directory=static_dir), name="static") + +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["GET", "POST"], + allow_headers=["*"], +) + + +# Create ./uploads folder if it doesn't exist +uploads = uploads or os.path.join(os.getcwd(), "uploads") +if not os.path.exists(uploads): + os.makedirs(uploads) + +# Initialize the vector store +vector_store = VectorStorage(directory=uploads) + + +async def create_chain( + messages: list[Message], + model=model_dir, + max_tokens_to_gen=2048, + temperature=0.5, + prompt: PromptTemplate = QA_PROMPT_TEMPLATE, + file: RAGFile | None = None, + key: str | None = None, +): + print( + f"Creating chain with key={key}, model={model}, max_tokens={max_tokens_to_gen}, temperature={temperature}, prompt={prompt}, file={file.title}" + ) + + llm = ChatOpenAI( + api_key=openai_api_key, + base_url=openai_api_base, + model=model_name, + verbose=True, + streaming=True, + ) + + # if llm is ALlamaCpp: + # llm.max_tokens = max_tokens_to_gen + # elif llm is AGPT4All: + # llm.n_predict = max_tokens_to_gen + # el + # if llm is AChatOllama: + # llm.max_tokens = max_tokens_to_gen + # if llm is VLLMAsync: + # llm.max_tokens = max_tokens_to_gen + + retriever = await vector_store.getRetriever(os.path.join(file.username, file.filename)) + + chat_memory = ChatMessageHistory() + + for message in messages: + if message.role == Role.HUMAN: + chat_memory.add_user_message(message.content) + elif message.role == Role.AI: + chat_memory.add_ai_message(message.content) + elif message.role == Role.SYSTEM: + chat_memory.add_message(message.content) + elif message.role == Role.FUNCTION: + chat_memory.add_message(message.content) + + memory = ConversationSummaryBufferMemory( + llm=llm, + chat_memory=chat_memory, + memory_key="chat_history", + input_key="question", + output_key="answer", + prompt=SUMMARY_PROMPT_TEMPLATE, + return_messages=True, + ) + + question_generator = LLMChain( + llm=llm, + prompt=CONDENSE_PROMPT_TEMPLATE, + memory=memory, + verbose=True, + output_key="answer", + ) + + stuff_chain = LLMChain( + llm=llm, + prompt=prompt, + verbose=True, + output_key="answer", + ) + + doc_chain = StuffDocumentsChain( + llm_chain=stuff_chain, + document_variable_name="context", + document_prompt=DOCUMENT_PROMPT_TEMPLATE, + verbose=True, + output_key="answer", + memory=memory, + ) + + return ConversationalRetrievalChain( + combine_docs_chain=doc_chain, + memory=memory, + retriever=retriever, + question_generator=question_generator, + return_generated_question=False, + return_source_documents=True, + output_key="answer", + verbose=True, + ) + + +router = APIRouter() + +@router.post( + "/chat", + summary="Chatbot", + description="Chatbot AI Service", +) +async def chat(request: ChatRequest): + chain: ConversationalRetrievalChain = await create_chain( + file=request.file, + messages=request.messages[:-1], + model=request.model.id, + max_tokens_to_gen=request.maxTokens, + temperature=request.temperature, + prompt=PromptTemplate.from_template( + f"{B_INST}{B_SYS}{request.prompt.strip()}{E_SYS}{E_INST}" + ), + ) + + # async for token in chain.astream(request.messages[-1].content): + # print(f"token={token}") + + json_string = json.dumps( + { + "question": request.messages[-1].content, + # "chat_history": [message.content for message in request.messages[:-1]], + } + ) + return LangchainStreamingResponse( + chain, + config={ + "inputs": json_string, + "callbacks": [ + StreamingStdOutCallbackHandler(), + TokenStreamingCallbackHandler(output_key="answer"), + SourceDocumentsStreamingCallbackHandler(), + ], + }, + ) + + +app.include_router(router, tags=["chat"]) + + +@app.get("/") +def root(): + return {"message": "Chatbot API"} + + +@app.get("/favicon.ico") +def favicon(): + file_name = "favicon.ico" + file_path = os.path.join(app.root_path, "static", file_name) + return FileResponse( + path=file_path, + headers={"Content-Disposition": "attachment; filename=" + file_name}, + ) + + +@app.post("/log") +def log_message(log_message: LogMessage): + try: + with open("log.txt", "a") as log_file: + log_file.write(log_message.message + "\n") + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error saving log: {e}") + return {"message": "Log saved successfully"} + + +@app.get("/models") +def get_models(): + # llama7B = AIModel( + # id="llama-2-7b-chat-ggml-q4_0", + # name="llama-2-7b-chat-ggml-q4_0", + # maxLength=2048, + # tokenLimit=2048, + # ) + # llama13B = AIModel( + # id="llama-2-13b-chat-ggml-q4_0", + # name="llama-2-13b-chat-ggml-q4_0", + # maxLength=2048, + # tokenLimit=2048, + # ) + llama70B = AIModel( + id="llama-2-70b.Q5_K_M", + name="llama-2-70b.Q5_K_M", + maxLength=2048, + tokenLimit=2048, + ) + models = AIModels(models=[llama70B]) + return models + + +@app.get("/titles") +def getTitles(): + titles = RAGFiles( + titles=[ + # RAGFile( + # versionId="d8ad3b1d-c33c-4524-9691-e93967d4d863", + # title="d8ad3b1d-c33c-4524-9691-e93967d4d863", + # state=State.Unavailable, + # ), + RAGFile( + versionId=collection.name, + title=collection.name, + state=State.InProcess + if collection.name in processing_books + else State.Processed, + ) + for collection in vector_store.list_collections() + if collection.name != "langchain" + ] + ) + return titles + + +processing_books: list[str] = [] +processing_books_lock = asyncio.Lock() + +logging.basicConfig(level=logging.ERROR) + + +@app.post("/titleState") +async def getTitleState(request: GetRAGFileStateRequest): + # FastAPI + Pydantic will throw a 422 Unprocessable Entity if the request isn't the right type. + # try: + logging.debug(f"Received getTitleState request: {request}") + titleStateRequest: GetRAGFileStateRequest = request + # except ValidationError as e: + # print(f"Error validating JSON: {e}") + # raise HTTPException(status_code=422, detail=str(e)) + # except json.JSONDecodeError as e: + # print(f"Error parsing JSON: {e}") + # raise HTTPException(status_code=422, detail="Invalid JSON format") + # check to see if the book has already been processed. + # return the proper State directly to response. + matchingCollection = next( + ( + x + for x in vector_store.list_collections() + if x.name == titleStateRequest.versionRef + ), + None, + ) + print("Got a Title State request for version " + titleStateRequest.versionRef) + if titleStateRequest.versionRef in processing_books: + return {"message": State.InProcess} + elif matchingCollection is not None: + return {"message": State.Processed} + else: + return {"message": State.Unavailable} + + +@app.post("/processRAGFile") +async def processRAGFile( + request: str = Form(...), + files: List[UploadFile] = File(...), +): + try: + logging.debug(f"Received processBook request: {request}") + # Parse the JSON string into a ProcessBookRequest object + fileRAGRequest: ProcessRAGFileRequest = parse_obj_as( + ProcessRAGFileRequest, json.loads(request) + ) + except ValidationError as e: + print(f"Error validating JSON: {e}") + raise HTTPException(status_code=422, detail=str(e)) + except json.JSONDecodeError as e: + print(f"Error parsing JSON: {e}") + raise HTTPException(status_code=422, detail="Invalid JSON format") + + try: + print( + f"Processing file {fileRAGRequest.filename} for user {fileRAGRequest.username}." + ) + # check to see if the file has already been processed. + # write html to subfolder + print(f"Writing file to path: {fileRAGRequest.username}/{fileRAGRequest.filename}...") + + for index, segment in enumerate(files): + filename = segment.filename if segment.filename else str(index) + subDir = f"{fileRAGRequest.username}" + with open(os.path.join(subDir, filename), "wb") as htmlFile: + htmlFile.write(await segment.read()) + + # write metadata to subfolder + print(f"Writing metadata to subfolder {fileRAGRequest.username}...") + with open(os.path.join({fileRAGRequest.username}, "metadata.json"), "w") as metadataFile: + metaData = { + "filename": fileRAGRequest.filename, + "username": fileRAGRequest.username, + "processDate": datetime.now().isoformat(), + } + metadataFile.write(json.dumps(metaData)) + + vector_store.retrievers[ + f"{fileRAGRequest.username}/{fileRAGRequest.filename}" + ] = await vector_store.initRetriever(f"{fileRAGRequest.username}/{fileRAGRequest.filename}") + + return { + "message": f"File {fileRAGRequest.filename} processed successfully." + } + except Exception as e: + logging.error(f"Error processing book: {e}") + return {"message": f"Error processing book: {e}"} + + +@app.exception_handler(HTTPException) +async def http_exception_handler(bookRequest: Request, exc: HTTPException): + logging.error(f"HTTPException: {exc.detail}") + return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail}) + diff --git a/swarms/server/server_models.py b/swarms/server/server_models.py new file mode 100644 index 00000000..1c4491b7 --- /dev/null +++ b/swarms/server/server_models.py @@ -0,0 +1,88 @@ +try: + from enum import StrEnum +except ImportError: + from strenum import StrEnum + +from pydantic import BaseModel +from swarms.prompts import QA_PROMPT_TEMPLATE_STR as DefaultSystemPrompt + +class AIModel(BaseModel): + id: str + name: str + maxLength: int + tokenLimit: int + + +class AIModels(BaseModel): + models: list[AIModel] + + +class State(StrEnum): + Unavailable = "Unavailable" + InProcess = "InProcess" + Processed = "Processed" + + +class RAGFile(BaseModel): + filename: str + title: str + username: str + state: State = State.Unavailable + + +class RAGFiles(BaseModel): + files: list[RAGFile] + + +class Role(StrEnum): + SYSTEM = "system" + ASSISTANT = "assistant" + USER = "user" + + +class Message(BaseModel): + role: Role + content: str + + +class ChatRequest(BaseModel): + id: str + model: AIModel = AIModel( + id="llama-2-70b.Q5_K_M", + name="llama-2-70b.Q5_K_M", + maxLength=2048, + tokenLimit=2048, + ) + messages: list[Message] = [ + Message(role=Role.SYSTEM, content="Hello, how may I help you?"), + Message(role=Role.USER, content=""), + ] + maxTokens: int = 2048 + temperature: float = 0 + prompt: str = DefaultSystemPrompt + file: RAGFile = RAGFile(filename="None", title="None", username="None") + + +class LogMessage(BaseModel): + message: str + + +class ConversationRequest(BaseModel): + id: str + name: str + title: RAGFile + messages: list[Message] + model: AIModel + prompt: str + temperature: float + folderId: str | None = None + + +class ProcessRAGFileRequest(BaseModel): + filename: str + username: str + + +class GetRAGFileStateRequest(BaseModel): + filename: str + username: str \ No newline at end of file diff --git a/swarms/server/server_prompts.py b/swarms/server/server_prompts.py new file mode 100644 index 00000000..00666cb7 --- /dev/null +++ b/swarms/server/server_prompts.py @@ -0,0 +1,78 @@ +from langchain.prompts.prompt import PromptTemplate + +B_INST, E_INST = "[INST]", "[/INST]" +B_SYS, E_SYS = "<>\n", "\n<>\n\n" + +QA_CONDENSE_TEMPLATE_STR = ( + "Given the following Chat History and a Follow Up Question, " + "rephrase the follow up question to be a new Standalone Question, " + "but make sure the new question is still asking for the same " + "information as the original follow up question. Respond only " + " with the new Standalone Question. \n" + "Chat History: \n" + "{chat_history} \n" + "Follow Up Question: {question} \n" + "Standalone Question:" +) + +CONDENSE_TEMPLATE = PromptTemplate.from_template( + f"{B_INST}{B_SYS}{QA_CONDENSE_TEMPLATE_STR.strip()}{E_SYS}{E_INST}" +) + +QA_PROMPT_TEMPLATE_STR = ( + "HUMAN: \n You are a helpful AI assistant. " + "Use the following context and chat history to answer the " + "question at the end with a helpful answer. " + "Get straight to the point and always think things through step-by-step before answering. " + "If you don't know the answer, just say 'I don't know'; " + "don't try to make up an answer. \n\n" + "{context}\n" + "{chat_history}\n" + "{question}\n\n" + "AI: Here is the most relevant sentence in the context: \n" +) + +QA_PROMPT_TEMPLATE = PromptTemplate.from_template( + f"{B_INST}{B_SYS}{QA_PROMPT_TEMPLATE_STR.strip()}{E_SYS}{E_INST}" +) + +DOCUMENT_PROMPT_TEMPLATE = PromptTemplate( + input_variables=["page_content"], template="{page_content}" +) + +_STUFF_PROMPT_TEMPLATE_STR = "Summarize the following context: {context}" + +STUFF_PROMPT_TEMPLATE = PromptTemplate.from_template( + f"{B_INST}{B_SYS}{_STUFF_PROMPT_TEMPLATE_STR.strip()}{E_SYS}{E_INST}" +) + +_SUMMARIZER_SYS_TEMPLATE = ( + B_INST + + B_SYS + + """Progressively summarize the lines of conversation provided, adding onto the previous summary returning a new summary. + EXAMPLE + Current summary: + The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good. + New lines of conversation: + Human: Why do you think artificial intelligence is a force for good? + AI: Because artificial intelligence will help humans reach their full potential. + New summary: + The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential. + END OF EXAMPLE""" + + E_SYS + + E_INST +) + +_SUMMARIZER_INST_TEMPLATE = ( + B_INST + + """Current summary: + {summary} + New lines of conversation: + {new_lines} + New summary:""" + + E_INST +) + +SUMMARY_PROMPT = PromptTemplate.from_template( + template=(_SUMMARIZER_SYS_TEMPLATE + "\n" + _SUMMARIZER_INST_TEMPLATE).strip() +) \ No newline at end of file diff --git a/swarms/server/static/favicon.ico b/swarms/server/static/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..988bba1c1ab35c5a6de7dfa08391648e622ea0c2 GIT binary patch literal 149514 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 literal 0 HcmV?d00001 diff --git a/swarms/server/utils.py b/swarms/server/utils.py new file mode 100644 index 00000000..89e3d7c8 --- /dev/null +++ b/swarms/server/utils.py @@ -0,0 +1,51 @@ +# modified from Lanarky source https://github.com/auxon/lanarky +from typing import Any + +import pydantic +from pydantic.fields import FieldInfo + +try: + from enum import StrEnum # type: ignore +except ImportError: + from enum import Enum + + class StrEnum(str, Enum): ... + + +PYDANTIC_V2 = pydantic.VERSION.startswith("2.") + + +def model_dump(model: pydantic.BaseModel, **kwargs) -> dict[str, Any]: + """Dump a pydantic model to a dictionary. + + Args: + model: A pydantic model. + """ + if PYDANTIC_V2: + return model.model_dump(**kwargs) + else: + return model.dict(**kwargs) + + +def model_dump_json(model: pydantic.BaseModel, **kwargs) -> str: + """Dump a pydantic model to a JSON string. + + Args: + model: A pydantic model. + """ + if PYDANTIC_V2: + return model.model_dump_json(**kwargs) + else: + return model.json(**kwargs) + + +def model_fields(model: pydantic.BaseModel) -> dict[str, FieldInfo]: + """Get the fields of a pydantic model. + + Args: + model: A pydantic model. + """ + if PYDANTIC_V2: + return model.model_fields + else: + return model.__fields__ \ No newline at end of file