created folder strucutre

.gitignore

@@ -0,0 +1,3 @@
+.venv
+.env
+__pycache__/

Dockerfile

@@ -0,0 +1,14 @@
+# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

ai_model/callAiModel.py

@@ -0,0 +1,48 @@
+from langchain.chains import LLMChain
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEndpoint
+
+# HuggingFace Endpoint Initialization
+repo_id = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+llmModel = HuggingFaceEndpoint(
+    repo_id=repo_id,
+    max_new_tokens=512,
+    temperature=0.5,
+    huggingfacehub_api_token="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",
+    task="text-generation", 
+)
+
+# Define the prompt template
+prompt = PromptTemplate(
+    input_variables=["logs", "query"],
+    template=(
+        """   You are an expert log analyzer. Analyze the system logs provided below. Return only precise and concise answers to the questions asked, formatted clearly and without unnecessary elaboration.
+            Logs: {logs}
+            User's Query: Analyze the logs and answer the following question:{query}
+            Be concise and direct in your responses."""
+    ),
+)
+
+# Memory setup
+memory = ConversationBufferMemory(
+    input_key="query",
+    memory_key="history",
+    return_messages=False,
+)
+
+# Create the LLM chain with memory
+conversation_chain = LLMChain(llm=llmModel, prompt=prompt, memory=memory)
+
+
+def generate_ai_response(user_query,logs):
+    try:
+        # Run the conversation chain
+        response = conversation_chain.run({"logs": logs, "query": user_query})
+        return response
+    except Exception as e:
+        print(e)
+        return f"An error occurred: {e}"
+
+
+# generate_ai_response ("who is prime minister of india")

ai_model/callGeminiModel.py

@@ -0,0 +1,27 @@
+import google.generativeai as genai
+from langchain.prompts import PromptTemplate
+
+# Configure Gemini
+api_key = "AIzaSyCWj2sHInMricyC2frSg3uwUgsd_QOGkLA"
+genai.configure(api_key=api_key)
+model = genai.GenerativeModel(model_name="gemini-1.5-flash-latest")
+
+# Define the Prompt Template
+log_prompt = PromptTemplate(
+    input_variables=["logs", "query"],
+    template=(
+        """You are an expert log analyzer. Analyze the system logs provided below. 
+        Return only precise and concise answers to the questions asked, formatted clearly.
+
+        Logs: {logs}
+        User's Query: {query}
+
+        Be concise and direct in your responses."""
+    ),
+)
+
+
+def generate_ai_response(user_query, logs):
+    formatted_prompt = log_prompt.format(logs=logs, query=user_query)
+    response = model.generate_content([formatted_prompt])
+    return response.text

config/database.py

@@ -0,0 +1,13 @@
+import pymongo
+import gridfs
+
+# database connection
+client = pymongo.MongoClient(
+    "mongodb+srv://soham2000:soham2000@cluster0.lbu4i.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0",
+    ssl=True,
+)
+db = client["nodetest"]
+user_collection = db["users"]
+chat_collection = db["chats"]
+log_collection = db["logs"] 
+fs = gridfs.GridFS(db)  # Initialize GridFS bucket

main.py

@@ -0,0 +1,14 @@
+from fastapi import FastAPI
+from routes.route import router
+from fastapi.middleware.cors import CORSMiddleware
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allow requests from any origin
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+app.include_router(router)

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.115.8
+uvicorn==0.34.0
+pydantic==2.10.6
+pymongo==4.11
+passlib[bcrypt]
+python-jose[cryptography]
+python-multipart==0.0.20
+langchain==0.3.17
+langchain-huggingface==0.1.2
+google-generativeai==0.8.4
+huggingface-hub==0.28.1

routes/route.py

@@ -0,0 +1,259 @@
+import json
+from fastapi import APIRouter, Body, HTTPException, Depends
+from ai_model.callGeminiModel import generate_ai_response
+from config.database import user_collection, chat_collection, log_collection
+from utils.auth import create_access_token, hash_password, verify_password, verify_token
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from schema.model import (
+    ChatData,
+    DateRangeModel,
+    QueryModel,
+    UserIdModel,
+    UserRegister,
+    UserLogin,
+)
+from datetime import datetime, timedelta, timezone
+from cryptography.fernet import Fernet
+
+security_scheme = HTTPBearer()
+router = APIRouter()
+activation_tokens = {}
+encryption_key = b"kFRvFTtpl6WDr0eceOteS5IAnv3ps0YtCavmUwllO0k="
+cipher = Fernet(encryption_key)
+
+
+# -------------------------------------------User Collections-------------------------------------------
+@router.post("/api/user/userLogin", tags=["user"])
+async def user_login(userLogin: UserLogin):
+    collection = user_collection
+    user = collection.find_one({"userName": userLogin.userName})
+    if not user or not verify_password(userLogin.password, user.get("password", "")):
+        raise HTTPException(status_code=401, detail="Incorrect username or password")
+    user_data = {
+        "email": user.get("email"),
+        "username": user.get("userName"),
+        "id": str(user.get("_id")),
+        "role": user.get("role"),
+    }
+    token = create_access_token({"sub": userLogin.userName})
+    response_data = {
+        "access_token": token,
+        "token_type": "bearer",
+        "user_data": user_data,
+    }
+    return response_data
+
+
+# User Registration Api
+@router.post("/api/user/registerUser", tags=["user"])
+async def create_user(user: UserRegister):
+    hashed_password = hash_password(user.password)
+    user_dict = user.dict()
+    user_dict["password"] = hashed_password
+    result = user_collection.insert_one(user_dict)
+    return {"message": "User created successfully", "userId": str(result.inserted_id)}
+
+
+# Api to show the registered users list
+@router.get(
+    "/api/user/getAllUsers", tags=["user"], dependencies=[Depends(security_scheme)]
+)
+async def get_all_user(token: HTTPAuthorizationCredentials = Depends(security_scheme)):
+    verify_token(token.credentials)
+    users = user_collection.find({})
+    user_list = []
+    for user in users:
+        user["_id"] = str(user["_id"])  # Convert ObjectId to string
+        user_list.append(user)
+    return user_list
+
+
+# -------------------------------------------Model Collections-------------------------------------------
+
+
+# Api to create new chat
+@router.post(
+    "/api/model/callModel", tags=["model"], dependencies=[Depends(security_scheme)]
+)
+async def call_ai_model(
+    query: QueryModel,
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    answer = generate_ai_response(query.query, query.logs)
+    return {"answer": answer}
+
+
+# Api to show the registered users list
+@router.post(
+    "/api/model/getAllChatHistoryByTitleId",
+    tags=["model"],
+    dependencies=[Depends(security_scheme)],
+)
+async def get_all_chat_history(
+    titleUId: str = Body(...),
+    userID: str = Body(...),
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    if not titleUId or not userID:
+        raise HTTPException(
+            status_code=400, detail="Both titleUId and userID are required"
+        )
+
+    # Find matching document from MongoDB
+    result = chat_collection.find_one({"titleUId": titleUId, "userID": userID})
+    if not result:
+        raise HTTPException(status_code=404, detail="No chat history found")
+
+    # Convert ObjectId and prepare response
+    result["_id"] = str(result["_id"])
+    result.pop("_id", None)  # Remove _id if not needed
+
+    # Ensure chat format consistency
+    result.setdefault("chat", [])
+    result["chat"] = [
+        {"question": entry.get("question", ""), "answer": entry.get("answer", "")}
+        for entry in result.get("chat", [])
+    ]
+
+    return result
+
+
+@router.post(
+    "/api/model/addUpdateChatHistory",
+    tags=["model"],
+    dependencies=[Depends(security_scheme)],
+)
+async def add_or_update_chat(
+    data: ChatData,
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    existing_entry = chat_collection.find_one(
+        {"userID": data.userID, "titleUId": data.titleUId}
+    )
+
+    if existing_entry:
+        # Extract existing chat questions to avoid duplication
+        existing_questions = {
+            entry["question"] for entry in existing_entry.get("chat", [])
+        }
+        new_entries = [
+            entry.dict()
+            for entry in data.chat
+            if entry.question not in existing_questions
+        ]
+
+        if new_entries:
+            chat_collection.update_one(
+                {"_id": existing_entry["_id"]},
+                {"$push": {"chat": {"$each": new_entries}}},
+            )
+            return {"message": "Chat updated successfully."}
+        else:
+            return {"message": "No new chat entries to add."}
+    else:
+        # Insert new document
+        new_data = data.dict()
+        chat_collection.insert_one(new_data)
+        return {"message": "Chat added successfully."}
+
+
+
+@router.post(
+    "/api/model/getAllTitleByUserId",
+    tags=["model"],
+    dependencies=[Depends(security_scheme)],
+)
+async def get_all_title(
+    data: UserIdModel,
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    chats = chat_collection.find({"userID": data.userID})
+    chatList = []
+    for chat in chats:
+        chatObj = {
+            "titleUId": chat["titleUId"],
+            "titleName": chat["titleName"],
+        }  # Convert ObjectId to string
+        chatList.append(chatObj)
+    chatList.reverse()
+    return chatList
+
+
+
+@router.post(
+    "/api/model/getAllLogsByDateRange",
+    tags=["model"],
+    dependencies=[Depends(security_scheme)],
+)
+async def get_logs_by_daterange(
+    data: DateRangeModel,
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    current_date = datetime.now(timezone.utc)  # Ensure timezone awareness
+
+    # Determine start_date based on duration format
+    if " - " in data.duration:  # Handle custom date range
+        try:
+            start_date_str, end_date_str = map(str.strip, data.duration.split(" - "))
+            start_date = datetime.fromisoformat(start_date_str)
+            end_date = datetime.fromisoformat(end_date_str)
+        except ValueError:
+            raise ValueError("Invalid date format. Use ISO 8601 format: YYYY-MM-DDTHH:MM:SS.ssssss+00:00 - YYYY-MM-DDTHH:MM:SS.ssssss+00:00")
+    else:  # Handle predefined durations
+        if data.duration == "1 Day":
+            start_date = current_date - timedelta(days=1)
+        elif data.duration == "Current Week":
+            start_date = current_date - timedelta(weeks=1)
+        elif data.duration == "Last 2 Weeks":
+            start_date = current_date - timedelta(weeks=2)
+        else:
+            raise ValueError("Invalid duration selected")
+        end_date = current_date
+
+    # Ensure timestamps are in UTC
+    start_date = start_date.astimezone(timezone.utc)
+    end_date = end_date.astimezone(timezone.utc)
+
+    duration_str = f"{start_date.isoformat()} - {end_date.isoformat()}"
+
+    logs_list = []
+    for encrypted_record in log_collection.find():
+        encrypted_data = encrypted_record["encrypted_data"]
+        decrypted_data = cipher.decrypt(encrypted_data).decode()
+        log = json.loads(decrypted_data)
+        log_timestamp = datetime.fromisoformat(log["Timestamp"]).astimezone(timezone.utc)
+
+        if start_date <= log_timestamp <= end_date:
+            logs_list.append(log)
+
+    return {"duration": duration_str, "logList": logs_list}
+
+
+@router.delete(
+    "/api/model/deleteChatHistoryByTitleId",
+    tags=["model"],
+    dependencies=[Depends(security_scheme)],
+)
+async def delete_chat_history(
+    titleUId: str = Body(...),
+    userID: str = Body(...),
+    token: HTTPAuthorizationCredentials = Depends(security_scheme),
+):
+    verify_token(token.credentials)
+    if not titleUId or not userID:
+        raise HTTPException(
+            status_code=400, detail="Both titleUId and userID are required"
+        )
+
+    # Attempt to delete the document
+    delete_result = chat_collection.delete_one({"titleUId": titleUId, "userID": userID})
+    
+    if delete_result.deleted_count == 0:
+        raise HTTPException(status_code=404, detail="No chat history found to delete")
+
+    return {"message": "Chat history deleted successfully"}

schema/model.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel
+from typing import List
+
+
+# user registration parameters
+class UserRegister(BaseModel):
+    name: str
+    userName: str
+    email: str
+    password: str
+
+
+# user login parameters
+class UserLogin(BaseModel):
+    userName: str
+    password: str
+
+
+class ChatEntry(BaseModel):
+    question: str
+    answer: str
+
+
+class ChatData(BaseModel):
+    userID: str
+    titleName: str
+    titleUId: str
+    dateRange: str
+    chat: List[ChatEntry]
+
+
+class UserIdModel(BaseModel):
+    userID: str
+
+
+class QueryModel(BaseModel):
+    query: str
+    logs: str
+
+
+class DateRangeModel(BaseModel):
+    duration: str

utils/auth.py

@@ -0,0 +1,40 @@
+from fastapi import HTTPException, status
+from fastapi.security import HTTPBearer
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+import bcrypt
+
+security = HTTPBearer()
+
+# Secret key for JWT token
+SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 180
+
+# Function to generate JWT token
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+# Function to hash a password
+def hash_password(password: str) -> str:
+    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+    return hashed_password
+
+# Function to verify a password
+def verify_password(plain_password: str, hashed_password: bytes) -> bool:
+    return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password)
+
+
+def verify_token(token: str):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        return payload
+    except JWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token"
+        )

utils/download_mongodb_logs.py

@@ -0,0 +1,51 @@
+from pymongo import MongoClient
+from cryptography.fernet import Fernet
+import json
+from datetime import datetime, timedelta
+
+# MongoDB connection string
+connection_string = "mongodb+srv://soham2000:soham2000@cluster0.lbu4i.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
+
+# Encryption key (generate this once and store securely)
+encryption_key = b"kFRvFTtpl6WDr0eceOteS5IAnv3ps0YtCavmUwllO0k="
+cipher = Fernet(encryption_key)
+
+client = MongoClient(connection_string)
+db = client["nodetest"] 
+collection = db["logs"] 
+logs_list = []
+# Calculate the date range based on the selected duration
+def download_logs(duration):
+    # Get the current date
+    current_date = datetime.now()
+
+    # Calculate the start and end date based on the selected duration
+    if duration == "1 day":
+        start_date = current_date - timedelta(days=1)
+        end_date = current_date
+    elif duration == "1 week":
+        start_date = current_date - timedelta(weeks=1)
+        end_date = current_date
+    elif duration == "2 weeks":
+        start_date = current_date - timedelta(weeks=2)
+        end_date = current_date
+    else:
+        raise ValueError("Invalid duration selected")
+
+    # Decrypt and filter logs based on the calculated date range
+    for encrypted_record in collection.find():
+        encrypted_data = encrypted_record["encrypted_data"]
+        decrypted_data = cipher.decrypt(encrypted_data).decode()
+        log = json.loads(decrypted_data)
+
+        # Parse the Timestamp field into a datetime object
+        log_timestamp = datetime.fromisoformat(log["Timestamp"])
+
+        # Check if the log falls within the specified date range
+        if start_date <= log_timestamp <= end_date:
+            logs_list.append(log)
+
+    return logs_list
+
+
+download_logs("1 week")

utils/email_validator.py

@@ -0,0 +1,37 @@
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import smtplib
+
+# Function to send activation email with HTML content
+def send_activation_email(email: str, activation_otp: int):
+    sender_email = "chandratresoham@gmail.com"  # Update with your email address
+    sender_password = "wbuc okcv hzzn iwyx"  # Update with your email password
+  # Update with your website URL
+    
+    # HTML content for the email body
+    email_body = f"""
+    <html>
+        <body>
+            <p>
+                Hello,<br><br>
+                You have successfully registered to the system.<br><br>
+                Please enter below otp to verify your accout<br><br>
+                <p style="font-size:17px; font-weight:bold">{activation_otp}</p><br><br>
+                Thank you!<br>
+            </p>
+        </body>
+    </html>
+    """
+
+    # Create MIMEText object with HTML content
+    message = MIMEMultipart("alternative")
+    message['From'] = sender_email
+    message['To'] = email
+    message['Subject'] = "Activate your account"
+    message.attach(MIMEText(email_body, 'html'))
+
+    # Connect to SMTP server and send email
+    with smtplib.SMTP('smtp.gmail.com', 587) as server:  # Update with your SMTP server details
+        server.starttls()
+        server.login(sender_email, sender_password)
+        server.sendmail(sender_email, email, message.as_string())