connect to -llm indic server

src/server/main.py

@@ -167,43 +167,125 @@ async def generate_audio(
         headers=headers
     )
 
-@app.post("/v1/generate_text/", response_model=TextGenerationResponse)
+
+class ChatRequest(BaseModel):
+    prompt: str
+    src_lang: str = "kan_Knda"  # Default to Kannada
+    tgt_lang: str = "kan_Knda"  # Default to Kannada
+
+    @field_validator("prompt")
+    def prompt_must_be_valid(cls, v):
+        if len(v) > 1000:
+            raise ValueError("Prompt cannot exceed 1000 characters")
+        return v.strip()
+
+class ChatResponse(BaseModel):
+    response: str
+
+
+async def call_external_translation(sentences: List[str], src_lang: str, tgt_lang: str) -> List[str]:
+    external_url = "https://gaganyatri-dhwani-server.hf.space/v1/translate"
+    payload = {
+        "sentences": sentences,
+        "src_lang": src_lang,
+        "tgt_lang": tgt_lang
+    }
+    try:
+        response = requests.post(
+            external_url,
+            json=payload,
+            headers={
+                "accept": "application/json",
+                "Content-Type": "application/json"
+            },
+            timeout=10
+        )
+        response.raise_for_status()
+        translations = response.json().get("translations", [])
+        if not translations or len(translations) != len(sentences):
+            logger.warning(f"Unexpected response format: {response.json()}")
+            raise ValueError("Invalid response from translation service")
+        return translations
+    except requests.Timeout:
+        logger.error("Translation request timed out")
+        raise HTTPException(status_code=504, detail="Translation service timeout")
+    except requests.RequestException as e:
+        logger.error(f"Error during translation: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Translation failed: {str(e)}")
+    except ValueError as e:
+        logger.error(f"Invalid response: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/v1/chat", response_model=ChatResponse)
 @limiter.limit(settings.chat_rate_limit)
-async def generate_text(
-    file: UploadFile = File(...),
-    language: str = Query(..., enum=["kannada", "hindi", "tamil"]),
-    #api_key: str = Depends(get_api_key),
-    request: Request = None,
-):
-    logger.info("Processing text generation request", extra={
-        "endpoint": "/v1/generate_text",
-        "filename": file.filename,
-        "client_ip": get_remote_address(request)
-    })
+async def chat(request: Request, chat_request: ChatRequest):
+    if not chat_request.prompt:
+        raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+    logger.info(f"Received prompt: {chat_request.prompt}, src_lang: {chat_request.src_lang}, tgt_lang: {chat_request.tgt_lang}")
     
-    start_time = time()
     try:
-        file_content = await file.read()
-        files = {"file": (file.filename, file_content, file.content_type)}
+        # Translate prompt to English if src_lang is not English
+        if chat_request.src_lang != "eng_Latn":
+            translated_prompt = await call_external_translation(
+                sentences=[chat_request.prompt],
+                src_lang=chat_request.src_lang,
+                tgt_lang="eng_Latn"
+            )
+            prompt_to_process = translated_prompt[0]
+            logger.info(f"Translated prompt to English: {prompt_to_process}")
+        else:
+            prompt_to_process = chat_request.prompt
+            logger.info("Prompt already in English, no translation needed")
+
+        # Call the external API instead of llm_manager.generate
+        external_url = "https://gaganyatri-llm-indic-server.hf.space/v1/chat"
+        payload = {
+            "prompt": prompt_to_process,
+            "src_lang": "eng_Latn",  # Sending English prompt to the external API
+            "tgt_lang": "eng_Latn"   # Expecting English response initially
+        }
         
-        external_url = f"{settings.external_text_gen_url}/generate_text/?language={language}"
         response = requests.post(
             external_url,
-            files=files,
-            headers={"accept": "application/json"},
+            json=payload,
+            headers={
+                "accept": "application/json",
+                "Content-Type": "application/json"
+            },
             timeout=10
         )
-        response.raise_for_status()
+        response.raise_for_status()  # Raise an exception for bad status codes
         
-        generated_text = response.json().get("text", "")
-        logger.info(f"Text generation completed in {time() - start_time:.2f} seconds")
-        return TextGenerationResponse(text=generated_text)
+        # Extract the response text from the API
+        response_data = response.json()
+        english_response = response_data.get("response", "")
+        logger.info(f"Generated English response from external API: {english_response}")
+
+        # Translate response to target language if tgt_lang is not English
+        if chat_request.tgt_lang != "eng_Latn":
+            translated_response = await call_external_translation(
+                sentences=[english_response],
+                src_lang="eng_Latn",
+                tgt_lang=chat_request.tgt_lang
+            )
+            final_response = translated_response[0]
+            logger.info(f"Translated response to {chat_request.tgt_lang}: {final_response}")
+        else:
+            final_response = english_response
+            logger.info("Response kept in English, no translation needed")
+
+        return ChatResponse(response=final_response)
     
     except requests.Timeout:
-        raise HTTPException(status_code=504, detail="Text generation service timeout")
+        logger.error("External chat API request timed out")
+        raise HTTPException(status_code=504, detail="Chat service timeout")
     except requests.RequestException as e:
-        logger.error(f"Text generation request failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Text generation failed: {str(e)}")
+        logger.error(f"Error calling external chat API: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Chat failed: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error processing request: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
 @app.post("/v1/process_audio/", response_model=AudioProcessingResponse)
 @limiter.limit(settings.chat_rate_limit)