AI Dev Team

.gitignore

@@ -38,6 +38,7 @@ docs/build
 .langgraph-data/
 .next/
 package-lock.json
+.github_repo_index/
 
 #Vim swp files
 *.swp

backend/chat/__init__.py

@@ -0,0 +1 @@
+from .chat import ChatAgentWithMemory

backend/chat/chat.py

@@ -0,0 +1,74 @@
+from fastapi import WebSocket
+import uuid
+
+from gpt_researcher.utils.llm import get_llm
+from gpt_researcher.memory import Memory
+from gpt_researcher.config import Config
+
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+
+from langchain_community.vectorstores import InMemoryVectorStore
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.tools import Tool, tool
+
+class ChatAgentWithMemory:
+    def __init__(
+        self,
+        report: str,
+        config_path,
+        headers,
+        vector_store = None
+    ):
+        self.report = report
+        self.headers = headers
+        self.config = Config(config_path)
+        self.vector_store = vector_store
+        self.graph = self.create_agent()
+
+    def create_agent(self):
+        """Create React Agent Graph"""
+        #If not vector store, split and talk to the report
+        if not self.vector_store:
+            documents = self._process_document(self.report)
+            provider = get_llm(self.config.llm_provider, model=self.config.fast_llm_model, temperature=self.config.temperature, max_tokens=self.config.fast_token_limit, **self.config.llm_kwargs).llm
+            self.chat_config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+            self.embedding = Memory(self.config.embedding_provider, self.headers).get_embeddings()
+            self.vector_store = InMemoryVectorStore(self.embedding)
+            self.vector_store.add_texts(documents)
+        graph = create_react_agent(provider, tools=[self.vector_store_tool(self.vector_store)], checkpointer=MemorySaver())
+        return graph
+
+    def vector_store_tool(self, vector_store) -> Tool:
+        """Create Vector Store Tool"""
+        @tool 
+        def retrieve_info(query):
+            """
+            Consult the report for relevant contexts whenever you don't know something
+            """
+            retriever = vector_store.as_retriever(k = 4)
+            return retriever.invoke(query)
+        return retrieve_info
+
+    def _process_document(self, report):
+        """Split Report into Chunks"""
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1024,
+            chunk_overlap=20,
+            length_function=len,
+            is_separator_regex=False,
+        )
+        documents = text_splitter.split_text(report)
+        return documents
+
+    async def chat(self, message, websocket):
+        """Chat with React Agent"""
+        inputs = {"messages": [("user", message)]}
+        response = await self.graph.ainvoke(inputs, config=self.chat_config)
+        ai_message = response["messages"][-1].content
+        if websocket is not None:
+            await websocket.send_json({"type": "chat", "content": ai_message})
+
+    def get_context(self):
+        """return the current context of the chat"""
+        return self.report

backend/server.py

@@ -71,6 +71,7 @@ def sanitize_filename(filename):
 async def websocket_endpoint(websocket: WebSocket):
     await manager.connect(websocket)
     try:
+        report = None
         while True:
             data = await websocket.receive_text()
             if data.startswith("start"):
@@ -80,14 +81,17 @@ async def websocket_endpoint(websocket: WebSocket):
                 source_urls = json_data.get("source_urls")
                 tone = json_data.get("tone")
                 headers = json_data.get("headers", {})
+                repo_name = json_data.get("repo_name")
+                print("repo_name in server.py", repo_name, flush=True)
+                branch_name = json_data.get("branch_name")
                 filename = f"task_{int(time.time())}_{task}"
                 sanitized_filename = sanitize_filename(
                     filename
                 )  # Sanitize the filename
                 report_source = json_data.get("report_source")
                 if task and report_type:
                     report = await manager.start_streaming(
-                        task, report_type, report_source, source_urls, tone, websocket, headers
+                        task, report_type, report_source, source_urls, tone, websocket, headers, repo_name, branch_name 
                     )
                     # Ensure report is a string
                     if not isinstance(report, str):
@@ -118,6 +122,11 @@ async def websocket_endpoint(websocket: WebSocket):
                     # You can add logic here to forward the feedback to the appropriate agent or update the research state
                 else:
                     print("Error: not enough parameters provided.")
+            elif data.startswith("chat") and report:
+                json_data = json.loads(data[4:])
+                headers = json_data.get("headers", {})
+                await manager.chat(json_data.get("message"), report, websocket, headers)
+
     except WebSocketDisconnect:
         await manager.disconnect(websocket)
 

backend/websocket_manager.py

@@ -5,10 +5,12 @@
 from fastapi import WebSocket
 
 from backend.report_type import BasicReport, DetailedReport
+from backend.chat import ChatAgentWithMemory
+
 from gpt_researcher.utils.enum import ReportType, Tone
 from multi_agents.main import run_research_task
 from gpt_researcher.master.actions import stream_output  # Import stream_output
-
+from multi_agents.dev_team.main import trigger_dev_team_flow
 class WebSocketManager:
     """Manage websockets"""
 
@@ -17,6 +19,7 @@ def __init__(self):
         self.active_connections: List[WebSocket] = []
         self.sender_tasks: Dict[WebSocket, asyncio.Task] = {}
         self.message_queues: Dict[WebSocket, asyncio.Queue] = {}
+        self.chat_agent = None
 
     async def start_sender(self, websocket: WebSocket):
         """Start the sender task."""
@@ -54,15 +57,30 @@ async def disconnect(self, websocket: WebSocket):
             del self.message_queues[websocket]
 
 
-    async def start_streaming(self, task, report_type, report_source, source_urls, tone, websocket, headers=None):
+    async def start_streaming(self, task, report_type, report_source, source_urls, tone, websocket, headers, repo_name, branch_name,):
         """Start streaming the output."""
         tone = Tone[tone]
-        report = await run_agent(task, report_type, report_source, source_urls, tone, websocket, headers)
+        report = await run_agent(task, report_type, report_source, source_urls, tone, websocket, headers, repo_name, branch_name)
         return report
 
+    async def chat(self, message, report, websocket, headers = None):
+        """Chat with the agent based message diff"""
+        if self.chat_agent and self.chat_agent.get_context() == report:
+            await self.chat_agent.chat(message, websocket)
+        else:
+            #Create a new chat Agent when we have a new report
+            config_path = ""
+            self.chat_agent = ChatAgentWithMemory(report, config_path, headers)
+            await self.chat_agent.chat(message, websocket)
 
-async def run_agent(task, report_type, report_source, source_urls, tone: Tone, websocket, headers=None):
+async def run_agent(task, report_type, report_source, source_urls, tone: Tone, websocket, headers, repo_name, branch_name):
     """Run the agent."""
+
+    print(
+        f"Triggering run_agent with repo_name as: {repo_name}",
+        flush=True,
+    )
+
     # measure time
     start_time = datetime.datetime.now()
     # add customized JSON config file path here
@@ -83,6 +101,15 @@ async def run_agent(task, report_type, report_source, source_urls, tone: Tone, w
             headers=headers
         )
         report = await researcher.run()
+    elif report_type == "dev_team":
+        # Trigger the dev_team process
+        report = await trigger_dev_team_flow(
+            repo_name=repo_name,
+            branch_name=branch_name,
+            query=task,
+            websocket=websocket,
+            stream_output=stream_output
+        )
     else:
         researcher = BasicReport(
             query=task,

docker-compose.yml

@@ -10,6 +10,7 @@ services:
     restart: always
     ports:
       - 8000:8000
+
   gptr-nextjs:
     pull_policy: build
     image: gptresearcher/gptr-nextjs
@@ -40,3 +41,17 @@ services:
       python -m pytest tests/report-types.py &&
       python -m pytest tests/vector-store.py
       "
+
+  discord-bot:
+    build:
+      context: ./docs/discord-bot
+      dockerfile: Dockerfile.dev
+    environment:
+      - DISCORD_BOT_TOKEN=${DISCORD_BOT_TOKEN}
+      - DISCORD_CLIENT_ID=${DISCORD_CLIENT_ID}
+    volumes:
+      - ./docs/discord-bot:/app
+    ports:
+      - 3001:3000
+    # profiles: ["discord"]
+    restart: always

docs/discord-bot/Dockerfile

@@ -0,0 +1,6 @@
+FROM node:18.17.0-alpine
+WORKDIR /app
+COPY ./package.json ./
+RUN npm install --legacy-peer-deps
+COPY . .
+CMD ["node", "index.js"]

docs/discord-bot/Dockerfile.dev

@@ -0,0 +1,7 @@
+FROM node:18.17.0-alpine
+WORKDIR /app
+COPY ./package.json ./
+RUN npm install --legacy-peer-deps
+RUN npm install -g nodemon
+COPY . .
+CMD ["nodemon", "index.js"]

docs/discord-bot/Readme.md

@@ -0,0 +1,53 @@
+## Setting up the Discord Bot
+
+Add a .env file in the root of the project and add the following:
+
+```
+DISCORD_BOT_TOKEN=
+DISCORD_CLIENT_ID=
+```
+
+You can fetch the token from the Discord Developer Portal.
+<br>
+Go to: https://discord.com/developers/applications/
+<br>
+Click the "New Application" button and give your bot a name.
+<br>
+Within the Oath2 tab, you can generate a URL to invite your bot to your server.
+First Select the "bot" scope.
+<img src="./img/oath2-url-generator.png">
+<br>
+Next, give your bot the proper permissions.
+<br>
+<img src="./img/bot-permissions.png">
+<br>
+Finally you can invite your bot via the generated invite URL. In the case of the gptr-bot, here is the invite URL to open in your browser:
+<br>
+https://discord.com/oauth2/authorize?client_id=1281438963034361856&permissions=1689934339898432&integration_type=0&scope=bot
+
+<br>
+Finally, if you created your own custom bot, copy-paste the token into your .env file you created above.
+
+
+### Running the bot
+
+```bash
+# run the bot
+npm run dev
+```
+
+### Installing NodeJS and NPM on Ubuntu
+
+```bash
+#install nvm
+wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.4/install.sh | bash
+
+export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
+[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
+
+# install nodejs
+nvm install 18.17.0
+
+# install npm
+sudo apt-get install npm
+```

docs/discord-bot/commands/ask.js

@@ -0,0 +1,10 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+    data: new SlashCommandBuilder()
+        .setName('ask')
+        .setDescription('Ask a question to the bot'),
+    async execute(interaction) {
+        await interaction.reply('Please provide your question.');
+    }
+};

docs/discord-bot/deploy-commands.js

@@ -0,0 +1,32 @@
+const { Client, GatewayIntentBits, REST, Routes } = require('discord.js');
+require('dotenv').config();
+
+// Create a new REST client and set your bot token
+const rest = new REST({ version: '10' }).setToken(process.env.DISCORD_BOT_TOKEN);
+
+// Define commands
+const commands = [
+    {
+        name: 'ping',
+        description: 'Replies with Pong!',
+    },
+    {
+        name: 'ask',
+        description: 'Ask a question to the bot',
+    },
+];
+
+// Deploy commands to Discord
+(async () => {
+    try {
+        console.log('Started refreshing application (/) commands.');
+
+        await rest.put(Routes.applicationCommands(process.env.DISCORD_CLIENT_ID), {
+            body: commands,
+        });
+
+        console.log('Successfully reloaded application (/) commands.');
+    } catch (error) {
+        console.error(error);
+    }
+})();