Initial commit

Author: YassKhazzan

.env_example

@@ -0,0 +1,4 @@
+GROQ_API_KEY="your api key here"
+JINA_API_KEY="your api key here"
+SERPER_API_KEY="your api key here"
+COHERE_API_KEY = "your api key here"

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.12-slim
+
+WORKDIR /workspace
+ENV HOME=/workspace
+
+ADD . /workspace
+
+RUN chown -R 42420:42420 /workspace
+
+# Install dependencies using apk and then Python packages
+RUN pip install -r requirements.txt
+
+EXPOSE 8080
+
+ENTRYPOINT ["uvicorn"]
+
+CMD ["main:app", "--host", "0.0.0.0", "--port", "8080"]
+
+
+# this docker image work for OVH CLOUD AI DEPLOY

__pycache__/build_context.cpython-312.pyc

@@ -0,0 +1,65 @@
+import logging
+from jina_rerank import get_reranking_jina
+from semantic_chunking import get_chunking
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+def build_context(sources_result, query, pro_mode, date_context):
+    """
+      Build context from search results.
+
+      :param sources_result: Dictionary containing search results
+      :param query: Search query string
+      :param pro_mode: Boolean indicating whether to use pro mode (reranking)
+      :param date_context: Date context string
+      :return: Built context as a string
+      """
+    try:
+        combined_list = []
+
+        organic_results = sources_result.get('organic', [])
+        graph = sources_result.get('graph')
+        answer_box = sources_result.get('answerBox')
+
+        snippets = [
+            f"{item['snippet']} {item.get('date', '')}"
+            for item in organic_results if 'snippet' in item  # Ensure there's always a snippet
+        ]
+
+        combined_list.extend(snippets)
+
+        html_text = " ".join(item['html'] for item in organic_results if 'html' in item)
+        if html_text is not None and len(html_text) > 200:
+            combined_list.extend(get_chunking(html_text))
+
+        # Extract top stories titles
+        if sources_result.get('topStories') is not None:
+            top_stories_titles = [item['title'] for item in sources_result.get('topStories') if 'title' in item]
+            combined_list.extend(top_stories_titles)
+
+        # Add descriptions and answers from 'graph' and 'answerBox'
+        if graph is not None:
+            graph_desc = graph.get('description')
+            if graph_desc:
+                combined_list.append(graph_desc)
+
+        if answer_box is not None:
+            for key in ['answer', 'snippet']:
+                if key in answer_box:  # Use this if you want to append regardless of the value (including None)
+                    combined_list.append(answer_box[key])
+
+        if pro_mode:
+            # you can choose to use jina or cohere for reranking
+            final_list = get_reranking_jina(combined_list, query + date_context, 15)
+        else:
+            final_list = combined_list
+
+        search_contexts = "\n\n".join(final_list)
+        print(search_contexts)
+        return search_contexts
+    except Exception as e:
+        logger.exception(f"An error occurred while building context: {e}")
+        return ""

__pycache__/extract_content_from_website.cpython-312.pyc

@@ -0,0 +1,41 @@
+import os
+
+import cohere
+
+
+# use ENV variables
+COHERE_API_KEY = os.getenv("COHERE_API_KEY")
+MODEL = "rerank-multilingual-v3.0"
+
+co = cohere.Client(api_key=COHERE_API_KEY)
+
+
+def get_reranking_cohere(docs, query, top_res):
+    """
+    Re-ranks a list of documents based on a query using Cohere's reranking API.
+
+    Args:
+    docs (list of str): List of documents to be re-ranked.
+    query (str): Query string to rank the documents against.
+    top_res (int): Number of top results to return.
+
+    Returns:
+    list of str: Top re-ranked documents based on the query.
+    """
+    try:
+        # Call the Cohere rerank API
+        response = co.rerank(
+            model=MODEL,
+            query=query,
+            documents=docs,
+            top_n=top_res,
+            return_documents=True
+        )
+
+        # Extract and return the texts of the top documents
+        return [item.document.text for item in response.results]
+
+    except Exception as e:
+        # Log the error and handle it as needed
+        print(f"An error occurred: {e}")
+        return []

__pycache__/groq_api.cpython-312.pyc

@@ -0,0 +1,32 @@
+from langchain_community.document_loaders import WebBaseLoader
+
+
+def extract_website_content(url):
+    """
+    Extracts and cleans the main content from a given website URL.
+
+    Args:
+    url (str): The URL of the website from which to extract content.
+
+    Returns:
+    str: The first 4000 characters of the cleaned main content if it is sufficiently long, otherwise an empty string.
+    """
+    try:
+        clean_text = []
+        loader = WebBaseLoader(url)
+        data = loader.load()
+
+        # Aggregate content using a list to avoid inefficient string concatenation in the loop
+        for doc in data:
+            if doc.page_content:  # Check if page_content is not None or empty
+                clean_text.append(doc.page_content.replace("\n", ""))
+
+                # Join all parts into a single string after processing
+        clean_text = "".join(clean_text)
+
+        # Return up to the first 4000 characters if the content is sufficiently long
+        return clean_text[:4000] if len(clean_text) > 200 else ""
+
+    except Exception as error:
+        print('Error extracting main content:', error)
+        return ""

__pycache__/jina_rerank.cpython-312.pyc

@@ -0,0 +1,58 @@
+import json
+import os
+from groq import Groq
+from langchain_core.prompts import PromptTemplate
+from prompts import search_prompt_system, relevant_prompt_system
+
+# use ENV variables
+MODEL = "llama3-70b-8192"
+api_key_groq = os.getenv("GROQ_API_KEY")
+
+
+client = Groq()
+
+
+def get_answer(query, contexts, date_context):
+    system_prompt_search = PromptTemplate(input_variables=["date_today"], template=search_prompt_system)
+
+    messages = [
+        {"role": "system", "content": system_prompt_search.format(date_today=date_context)},
+        {"role": "user", "content": "User Question : " + query + "\n\n CONTEXTS :\n\n" + contexts}
+    ]
+
+    try:
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=messages,
+            stream=True,
+            stop=None,
+        )
+
+        for chunk in stream:
+            if chunk.choices[0].delta.content is not None:
+                yield chunk.choices[0].delta.content
+
+    except Exception as e:
+        print(f"Error during get_answer_groq call: {e}")
+        yield "data:" + json.dumps(
+            {'type': 'error', 'data': "We are currently experiencing some issues. Please try again later."}) + "\n\n"
+
+
+def get_relevant_questions(contexts, query):
+    try:
+        response = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {"role": "system",
+                 "content": relevant_prompt_system
+                 },
+                {"role": "user",
+                 "content": "User Query: " + query + "\n\n" + "Contexts: " + "\n" + contexts + "\n"}
+            ],
+            response_format={"type": "json_object"},
+        )
+
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Error during RELEVANT GROQ ***************: {e}")
+        return {}

__pycache__/main.cpython-312.pyc

@@ -0,0 +1,51 @@
+import os
+import requests
+from typing import List
+import logging
+from requests.exceptions import RequestException
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Constants
+API_URL = "https://api.jina.ai/v1/rerank"
+API_KEY = os.getenv("JINA_API_KEY")
+MODEL = "jina-reranker-v2-base-multilingual"
+HEADERS = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {API_KEY}"
+}
+
+
+def get_reranking_jina(docs: List[str], query: str, top_res: int) -> List[str]:
+    """
+    Get reranked documents using Jina AI API.
+
+    :param docs: List of documents to rerank
+    :param query: Query string
+    :param top_res: Number of top results to return
+    :return: List of reranked documents
+    """
+    try:
+        data = {
+            "model": MODEL,
+            "query": query,
+            "documents": docs,
+            "top_n": top_res
+        }
+
+        response = requests.post(API_URL, headers=HEADERS, json=data, timeout=10)
+        response.raise_for_status()
+        response_data = response.json()
+
+        return [item['document']['text'] for item in response_data.get('results', [])]
+
+    except RequestException as e:
+        logger.error(f"HTTP error occurred while reranking: {e}")
+    except KeyError as e:
+        logger.error(f"Unexpected response format: {e}")
+    except Exception as e:
+        logger.exception(f"An unexpected error occurred: {e}")
+
+    return []

__pycache__/prompts.cpython-312.pyc

@@ -0,0 +1,77 @@
+import orjson as json
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from fastapi.responses import StreamingResponse
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from groq_api import get_answer, get_relevant_questions
+from sources_searcher import get_sources
+from build_context import build_context
+from sources_manipulation import populate_sources
+
+
+app = FastAPI()
+
+# allow_origins=["https://openperplex.com"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST"],  # Allow all methods or specify like ["POST", "GET"]
+    allow_headers=["*"],  # Allow all headers or specify
+)
+
+load_dotenv()
+
+
+@app.get("/")
+def root():
+    return {"message": "hello world openperplex v1"}
+
+
+@app.get("/up_test")
+def up_test():
+    # test for kamal deploy
+    return {"status": "ok"}
+
+
+# you can change to post if typical your query is too long
+@app.get("/search")
+def ask(query: str, date_context: str, stored_location: str, pro_mode: bool = False):
+    if not query:
+        raise HTTPException(status_code=400, detail="Query cannot be empty")
+
+    def generate():
+        try:
+            sources_result = get_sources(query, pro_mode, stored_location)
+            yield "data:" + json.dumps({'type': 'sources', 'data': sources_result}).decode() + "\n\n"
+
+            if sources_result.get('organic') is not None and pro_mode is True:
+                # set the number of websites to scrape : here = 2
+                sources_result['organic'] = populate_sources(sources_result['organic'], 2)
+
+            search_contexts = build_context(sources_result, query, pro_mode, date_context)
+
+            for chunk in get_answer(query, search_contexts, date_context):
+                yield "data:" + json.dumps({'type': 'llm', 'text': chunk}).decode() + "\n\n"
+
+            try:
+                relevant_questions = get_relevant_questions(search_contexts, query)
+                relevant_json = json.loads(relevant_questions)
+                yield "data:" + json.dumps({'type': 'relevant', 'data': relevant_json}).decode() + "\n\n"
+            except Exception as e:
+                print(f"error in relevant questions main.py {e}")
+                yield "data:" + json.dumps({'type': 'relevant', 'data': []}).decode() + "\n\n"
+
+            yield "data:" + json.dumps({'type': 'finished', 'data': ""}).decode() + "\n\n"
+            yield "event: end-of-stream\ndata: null\n\n"
+
+        except Exception as e:
+            print(e)
+            yield "data:" + json.dumps(
+                {'type': 'error',
+                 'data': "We are currently experiencing some issues. Please try again later."}).decode() + "\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")