Upload 15 files

api_client/api.py

@@ -0,0 +1,12 @@
+import os
+from config import settings
+from langchain_groq import ChatGroq
+
+os.environ["GROQ_API_KEY"] = settings.Groq_api_key 
+def llm():
+    llm = ChatGroq(
+        model= "llama-3.3-70b-versatile",
+        temperature=0 
+    )
+    return llm
+llm=llm()

config.py

@@ -0,0 +1,11 @@
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    Groq_api_key:str
+
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()
+

data/schemaClass.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List,Optional
+class State(BaseModel):
+    text: str
+    classification: Optional[str] = None
+    entities: Optional[List[str]] = None
+    summary: Optional[str] = None
+
+
+class TextInput(BaseModel):
+    text:str
+
+class TextProcessingResponseAPI(BaseModel):
+    classification: str
+    entities: list[str]
+    summary: str

dockerfile

@@ -0,0 +1,10 @@
+# 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.10-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --upgrade pip && pip install -r requirements.txt --no-cache-dir
+COPY . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

main.py

@@ -0,0 +1,28 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routers import textProcessing
+from routers import downloadingDocs
+
+# Create the FastAPI app
+app = FastAPI()
+
+
+origins = ["*"]  # Allow any website to access the API; you can specify specific domains if needed
+
+# Add CORS middleware to handle cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],  # Allow all methods (GET, POST, etc.), adjust based on your needs
+    allow_headers=["*"],  # Allow all headers in requests
+)
+
+
+# Include the text processing router
+app.include_router(textProcessing.router)
+app.include_router(downloadingDocs.router)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the Text Processing API!"}

routers/downloadingDocs.py

@@ -0,0 +1,10 @@
+from data.schemaClass import TextInput
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+
+router = APIRouter()
+
+@router.get("/download_report")
+def download_rep():
+    file_path = "analysis_report.docx"
+    return FileResponse(path=file_path,filename="Text_Analysis_Report.docx",media_type='application/vnd.openxmlformats-officedocument.wordprocessingml.document')

routers/textProcessing.py

@@ -0,0 +1,27 @@
+from usecase.workflow import langgraphPipeline
+from data.schemaClass import TextInput
+from fastapi import APIRouter, HTTPException 
+from fastapi.responses import JSONResponse
+import streamlit as st
+router = APIRouter()
+
+@router.post("/process_text")
+def process_text(input_data:TextInput):
+    try:
+        pipeline_app = langgraphPipeline()
+        
+        # state_input = {"text":input_data.text}
+        state_input = {"text":"hi"}
+
+        # print(f"{input_data.text} type is {type(input_data.text)}")
+        result = pipeline_app.invoke(state_input)
+
+        return JSONResponse(
+            content={
+                "classification": result.get("classification", ""),
+                "entities": result.get("entities", []),
+                "summary": result.get("summary", "")
+            }
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500,detail=str(e))

usecase/classificationNode.py

@@ -0,0 +1,22 @@
+from data.schemaClass import State
+from langchain.prompts import PromptTemplate
+from langchain.schema import HumanMessage
+from api_client.api import llm
+
+
+def classification_node_usecase(state: State):
+    """
+    Classify the text into Categories: News, Blog, Research, or Other
+    """
+    prompt = PromptTemplate(
+        input_variables=["text"],
+        template="Classify the following text into one of the categories: News, Blog, Research, or Other.\n\nText:{text}\n\nCategory:"
+    )
+
+    message = HumanMessage(content=prompt.format(text=state.text))
+    classification = llm.invoke([message]).content.strip()
+
+    # Update the state with the classification result
+    state.classification = classification
+
+    return state  # Return the updated state with the classification

usecase/entity_extractionNode.py

@@ -0,0 +1,21 @@
+from data.schemaClass import State
+from langchain.prompts import PromptTemplate
+from langchain.schema import HumanMessage
+from api_client.api import llm
+
+
+def entity_extraction_node_usecase(state: State):
+    """
+    Extract all the entities (Person, Organization, Location) from the text
+    """
+    prompt = PromptTemplate(
+        input_variables=["text"],
+        template="Extract all the entities (Person, Organization, Location) from the following text. Provide the result as a comma-separated list.\n\nText:{text}\n\nEntities:"
+    )
+    message = HumanMessage(content=prompt.format(text=state.text))  # Access state.text instead of state["text"]
+    entities = llm.invoke([message]).content.strip().split(", ")  # Get a list of entities
+
+    # Update the state with the extracted entities
+    state.entities = entities
+
+    return state  # Return the updated state with the entities

usecase/summarizationNode.py

@@ -0,0 +1,21 @@
+from data.schemaClass import State
+from langchain.prompts import PromptTemplate
+from langchain.schema import HumanMessage
+from api_client.api import llm
+
+
+def summarization_node_usecase(state: State):
+    """
+    Summarize the text in one short sentence
+    """
+    prompt = PromptTemplate(
+        input_variables=["text"],
+        template="Summarize the following text in one short sentence.\n\nText:{text}\n\nSummary:"
+    )
+    message = HumanMessage(content=prompt.format(text=state.text))  # Access state.text instead of state["text"]
+    summary = llm.invoke([message]).content.strip()
+
+    # Update the state with the summary
+    state.summary = summary
+
+    return state  # Return the updated state with the summary

usecase/workflow.py

@@ -0,0 +1,25 @@
+from langgraph.graph import StateGraph, END
+from data.schemaClass import State
+from usecase.classificationNode import classification_node_usecase
+from usecase.entity_extractionNode import entity_extraction_node_usecase
+from usecase.summarizationNode import summarization_node_usecase
+
+
+def langgraphPipeline():
+    workflow = StateGraph(State)
+    # Add nodes to the graph
+    workflow.add_node("classification_node", classification_node_usecase)
+    workflow.add_node("entity_extraction", entity_extraction_node_usecase)
+    workflow.add_node("summarization", summarization_node_usecase)
+
+    # Add edges to the graph
+    workflow.set_entry_point("classification_node") # Set the entry point of the graph
+    workflow.add_edge("classification_node", "entity_extraction")
+    workflow.add_edge("entity_extraction", "summarization")
+    workflow.add_edge("summarization", END)
+
+    # Compile the graph
+    app = workflow.compile()
+
+    return app
+