Synced repo using 'sync_with_huggingface' Github Action

.env

@@ -8,6 +8,9 @@ LANGCHAIN_API_KEY=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
 LANGCHAIN_PROJECT=pr-earnest-miracle-23
 TYPESENSE_API_KEY=xyz
 TYPESENSE_DATA_DIR=/
-TYPESENSE_PORT=8108
+llama3-70b-8192TYPESENSE_PORT=8108
 DETA_TOKEN=PBM2kDUq_bqjZNN3DgFfBHPMZU9nk8nj7EGpnu5gq
 DETA_TOKEN=85QtEsbv_7B1UUYXKvu1FwiHX7NVZPnRcA7jLjw6E
+OPENAI_MODEL_NAME=llama3-70b-8192
+OPENAI_API_KEY=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
+OPENAI_API_BASE=https://api.groq.com/openai/v1

Dockerfile

@@ -14,5 +14,5 @@ RUN pip install --no-cache-dir --upgrade -r requirements.txt
 EXPOSE 7860
 
 COPY --chown=user . /app
-CMD ["python", "main.py"]
 
+CMD ["python", "main.py"]

api.py

@@ -3,7 +3,7 @@ import os
 from dotenv import load_dotenv
 
 import asyncio
-from fastapi import FastAPI, Body, File, UploadFile
+from fastapi import FastAPI, Body, File, UploadFile, HTTPException
 from fastapi.responses import StreamingResponse
 from typing import List, AsyncIterable, Annotated, Optional
 from enum import Enum
@@ -22,7 +22,9 @@ from langchain_core.documents import Document
 from in_memory import load_all_documents
 from langchain_nomic.embeddings import Embeddings, NomicEmbeddings
 from loader import load_web_content, load_youtube_content
-from praisonai import PraisonAI
+from get_pattern import generate_pattern
+from get_agents import process_agents
+
 
 # ################################### FastAPI setup ############################################
 app = FastAPI()
@@ -50,6 +52,7 @@ app.add_middleware(
 load_dotenv()
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 GROQ_API_BASE = os.environ.get("GROQ_API_BASE")
+OPENAI_MODEL_NAME = os.environ.get("OPENAI_MODEL_NAME")
 embedding_model = NomicEmbeddings(model="nomic-embed-text-v1.5")
 
 
@@ -90,7 +93,7 @@ async def generate_chunks(query: str) -> AsyncIterable[str]:
         openai_api_base=GROQ_API_BASE,
         api_key=GROQ_API_KEY,
         temperature=0.0,
-        model_name="mixtral-8x7b-32768",
+        model_name=OPENAI_MODEL_NAME,  # "mixtral-8x7b-32768",
         streaming=True,  # ! important
         verbose=True,
         callbacks=[callback]
@@ -136,11 +139,16 @@ async def generate_chunks(query: str) -> AsyncIterable[str]:
 
 
 # ################################### Models ########################################
+class QuestionType(str, Enum):
+    PATTERN = "PATTERN"
+    AGENTS = "AGENTS"
+    RAG = "RAG"
+
 class Input(BaseModel):
     question: str
-    type: Optional[Enum('type', ['PATTERN', 'AGENTS', 'RAG'])] 
+    type: QuestionType
     pattern: Optional[str]
-    chat_history: List[str]  # Define the type for chat_history
+    chat_history: List[str]
 
 
 class Metadata(BaseModel):
@@ -164,32 +172,26 @@ def read_root():
     return {"Hello": "World from Marigen"}
 
 
-@app.post("/chat")
+@app.post("/chat", response_class=StreamingResponse)
 async def chat(query: RequestBody = Body(...)):
-    result = None
     print(query.input.question)
     print(query.input.type)
 
-    if query.input.type == 'PATTERN':
+    if query.input.type == QuestionType.PATTERN:
         print(query.input.pattern)
+        pattern = query.input.pattern
+        gen = generate_pattern(pattern=pattern, query=query.input.question)
+        return StreamingResponse(gen, media_type="text/event-stream")
 
-        return query.input.pattern
-
-    elif query.input.type == 'AGENTS':
-        praisonai = PraisonAI(
-        auto=query.input.question,
-        framework="autogen"
-    )
-        print(praisonai.framework)
-        result = praisonai.run()
-        return result
+    elif query.input.type == QuestionType.AGENTS:
+        gen = process_agents(query.input.question)
+        return StreamingResponse(gen, media_type="text/event-stream")
 
-    elif query.input.type == 'RAG':
+    elif query.input.type == QuestionType.RAG:
         gen = generate_chunks(query.input.question)
         return StreamingResponse(gen, media_type="text/event-stream")
 
-    return result
-
+    raise HTTPException(status_code=400, detail="No accurate response for your given query")
 
 @app.post("/uploadfiles")
 async def create_upload_files(

get_agents.py

@@ -0,0 +1,20 @@
+import asyncio
+from praisonai import PraisonAI
+from typing import List, AsyncIterable, Annotated, Optional
+
+async def process_agents(query: str) -> AsyncIterable[str]:
+
+    # Create PraisonAI instance and task
+    praisonai = PraisonAI(auto=query)
+    print(praisonai.framework)
+    
+    # Run the task and await the result
+    task = praisonai.main()
+
+    
+    # print(task)
+    # Assuming `result` is an iterable of strings
+    for item in task:
+        yield item
+
+    # await task

get_pattern.py

@@ -0,0 +1,86 @@
+import os
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from dotenv import load_dotenv
+from typing import List, AsyncIterable, Annotated, Optional
+from langchain.callbacks import AsyncIteratorCallbackHandler
+from langchain_core.output_parsers import StrOutputParser
+import asyncio
+import datetime
+
+
+load_dotenv()
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+GROQ_API_BASE = os.environ.get("GROQ_API_BASE")
+GROQ_MODEL_NAME = os.environ.get("OPENAI_MODEL_NAME")
+
+def read_pattern_files(pattern: str) -> (str, str):
+    system_file = 'system.md'
+    user_file = 'user.md'
+    system_content = ""
+    user_content = ""
+    pattern_dir = "patterns"
+    
+    # Construct the full paths
+    system_file_path = os.path.abspath(os.path.join(pattern_dir, pattern, system_file))
+    user_file_path = os.path.abspath(os.path.join(pattern_dir, pattern, user_file))
+    
+    print(system_file_path)
+    print(user_file_path)
+    
+    # Check if system.md exists
+    if os.path.exists(system_file_path):
+        with open(system_file_path, 'r') as file:
+            system_content = file.read()
+    
+    # Check if user.md exists
+    if os.path.exists(user_file_path):
+        with open(user_file_path, 'r') as file:
+            user_content = file.read()
+    
+    return system_content, user_content
+
+
+
+async def generate_pattern(pattern: str, query: str) -> AsyncIterable[str] :
+
+    callback = AsyncIteratorCallbackHandler()
+
+    chat = ChatOpenAI(
+        openai_api_base=GROQ_API_BASE,
+        api_key=GROQ_API_KEY,
+        temperature=0.0,
+        model_name= "mixtral-8x7b-32768", #GROQ_MODEL_NAME,
+        streaming=True,  # ! important
+        verbose=True,
+        callbacks=[callback]
+    )
+
+    system, usr_content = read_pattern_files(pattern=pattern)
+    print('Sys Content -- > ')
+    print(system)
+    print('User Content --- > ')
+    print(usr_content)
+
+    human = usr_content + "{text}"
+    prompt = ChatPromptTemplate.from_messages([("system", system), ("human", human)])
+
+    chain = prompt | chat | StrOutputParser()
+    
+
+    task = asyncio.create_task(
+        chain.ainvoke({"text": query})
+    )
+    index = 0
+    try:
+        async for token in callback.aiter():
+            print(index, ": ", token, ": ", datetime.datetime.now().time())
+            index = index + 1
+            yield token
+    except Exception as e:
+        print(f"Caught exception: {e}")
+    finally:
+        callback.done.set()
+
+    await task
+

requirements.txt

@@ -129,4 +129,5 @@ openpyxl
 pysqlite3-binary
 langchain_nomic
 pydub
-praisonai
+praisonai==0.0.57
+langchain_groq

test.yaml

@@ -0,0 +1,38 @@
+framework: crewai
+topic: what is the meaning of life, for a student
+roles:
+  researcher:
+    backstory: Experienced in search queries and extracting relevant information from
+      various sources.
+    goal: Gather relevant information on the meaning of life for students
+    role: Researcher
+    tasks:
+      information_gathering:
+        description: Gather relevant information on the meaning of life for students
+          from various sources, including articles, books, and websites.
+        expected_output: Document with collected information and relevant sources.
+    tools:
+    - ''
+  analyst:
+    backstory: Skilled in pattern recognition and extracting insights from data.
+    goal: Analyze and identify key themes and insights
+    role: Analyst
+    tasks:
+      theme_identification:
+        description: Analyze the gathered information and identify key themes and
+          insights on the meaning of life for students.
+        expected_output: Document with identified themes and insights.
+    tools:
+    - ''
+  writer:
+    backstory: Talented in crafting compelling narratives and essays.
+    goal: Write a cohesive and inspiring essay on the meaning of life for students
+    role: Writer
+    tasks:
+      essay_writing:
+        description: Write a cohesive and inspiring essay on the meaning of life for
+          students, incorporating the identified themes and insights.
+        expected_output: Well-structured essay on the meaning of life for students.
+    tools:
+    - ''
+dependencies: []

trained_agents_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:926248e52d1fa532c317e37da24ed652ae64110f8219cb5e061668bd3091f048
+size 5