Merge pull request #13 from Azure-Samples/gk/entra-login

Refactors app for container app hosting

Author: thegovind

azure.yaml

@@ -13,8 +13,10 @@ services:
   web:
     project: ./frontend
     language: js
-    host: staticwebapp
-    dist: dist
+    host: containerapp
+    docker:
+      path: ./Dockerfile
+      context: ./frontend
 infra:
   provider: bicep
   path: infra

backend/Dockerfile

@@ -16,8 +16,8 @@ COPY pyproject.toml poetry.lock ./
 # Configure poetry: Don't create a virtual environment
 RUN poetry config virtualenvs.create false
 
-# Install dependencies
-RUN poetry install --no-dev
+# Install dependencies (without installing the current project)
+RUN poetry install --only=main --no-root
 
 # Copy application code
 COPY . .

backend/app/agents/curator.py

@@ -78,7 +78,7 @@ def _extract_company(self, filename: str) -> str:
         else:
             return "Unknown"
 
-    def _extract_year(self, filename: str) -> int:
+    def _extract_year(self, filename: str) -> str:
         import re
         year_match = re.search(r'20\d{2}', filename)
-        return int(year_match.group()) if year_match else 2024
+        return str(year_match.group()) if year_match else "2024"

backend/app/agents/orchestrator.py

@@ -1,6 +1,6 @@
 from semantic_kernel.kernel import Kernel
 from semantic_kernel.agents import ChatCompletionAgent
-from semantic_kernel.agents.orchestration.sequential import SequentialOrchestration
+# from semantic_kernel.agents.orchestration.sequential import SequentialOrchestration  # Not available in semantic_kernel 1.3.0
 from semantic_kernel.connectors.ai.open_ai.services.azure_chat_completion import AzureChatCompletion
 from semantic_kernel.contents import ChatMessageContent
 from typing import List, Dict, AsyncIterator, Optional
@@ -98,7 +98,7 @@ async def create_plan(self, request: Dict) -> List[str]:
 
         return ["RetrieverAgent", "WriterAgent"]
 
-    async def create_sk_orchestration(self, mode: str) -> Optional[SequentialOrchestration]:
+    async def create_sk_orchestration(self, mode: str) -> Optional[object]:
         """Create SK SequentialOrchestration based on mode using registry config or fallback"""
         await self.initialize_sk_agents()
 
@@ -127,14 +127,16 @@ async def create_sk_orchestration(self, mode: str) -> Optional[SequentialOrchest
             return None
 
         try:
-            orchestration = SequentialOrchestration(
-                members=agent_sequence,
-                name=f"{mode}_orchestration",
-                description=orchestration_config.get("description", f"Sequential orchestration for {mode} workflow") if orchestration_config else f"Sequential orchestration for {mode} workflow"
-            )
-            
-            self.orchestrations[mode] = orchestration
-            return orchestration
+            # orchestration = SequentialOrchestration(
+            #     members=agent_sequence,
+            #     name=f"{mode}_orchestration",
+            #     description=orchestration_config.get("description", f"Sequential orchestration for {mode} workflow") if orchestration_config else f"Sequential orchestration for {mode} workflow"
+            # )
+            # 
+            # self.orchestrations[mode] = orchestration
+            # return orchestration
+            print(f"SK orchestration not available in semantic_kernel 1.3.0, using fallback")
+            return None
         except Exception as e:
             print(f"Error creating SK orchestration: {e}")
             return None

backend/app/agents/retriever.py

@@ -18,7 +18,8 @@ def __init__(self, kernel):
             from azure.search.documents.agent.aio import KnowledgeAgentRetrievalClient
             self.agent_client = KnowledgeAgentRetrievalClient(
                 endpoint=settings.search_endpoint,
-                credential=AzureKeyCredential(settings.search_admin_key)
+                credential=AzureKeyCredential(settings.search_admin_key),
+                agent_name="retriever_agent"
             )
             self.use_agentic_retrieval = True
         except ImportError:

backend/app/agents/verifier.py

@@ -1,18 +1,19 @@
 from typing import List, Dict
 import re
-from openai import AsyncAzureOpenAI
 from ..core.config import settings
+from ..services.azure_services import azure_service_manager
 
 class VerifierAgent:
     def __init__(self, kernel):
         self.kernel = kernel
-        self.client = AsyncAzureOpenAI(
-            azure_endpoint=settings.openai_endpoint.split('/openai/deployments')[0],
-            api_key=settings.openai_key,
-            api_version="2025-01-01-preview"
-        )
+        self.client = None
+    
+    async def _ensure_client(self):
+        if self.client is None:
+            self.client = azure_service_manager.async_openai_client
 
     async def get_response(self, retrieved_docs: List[Dict], query: str) -> str:
+        await self._ensure_client()
         verified_docs = await self.invoke(retrieved_docs, query)
         avg_confidence = sum(doc['confidence'] for doc in verified_docs) / len(verified_docs) if verified_docs else 0
         return f"Verified {len(verified_docs)} documents with average confidence: {avg_confidence:.2f}"
@@ -23,6 +24,7 @@ async def invoke_stream(self, retrieved_docs: List[Dict], query: str):
             yield f"Verified: {doc['company']} {doc['year']} (confidence: {doc['confidence']:.2f})\n"
 
     async def invoke(self, retrieved_docs: List[Dict], query: str) -> List[Dict]:
+        await self._ensure_client()
         verified_docs = []
 
         for doc in retrieved_docs:

backend/app/agents/writer.py

@@ -1,25 +1,27 @@
 from typing import List, Dict, AsyncIterator
 import re
 import asyncio
-from openai import AsyncAzureOpenAI
 from ..core.config import settings
+from ..services.azure_services import azure_service_manager
 
 class WriterAgent:
     def __init__(self, kernel):
         self.kernel = kernel
-        self.client = AsyncAzureOpenAI(
-            azure_endpoint=settings.openai_endpoint.split('/openai/deployments')[0],
-            api_key=settings.openai_key,
-            api_version="2025-01-01-preview"
-        )
+        self.client = None
+    
+    async def _ensure_client(self):
+        if self.client is None:
+            self.client = azure_service_manager.async_openai_client
 
     async def get_response(self, retrieved_docs: List[Dict], query: str) -> str:
+        await self._ensure_client()
         response_parts = []
         async for chunk in self.invoke_stream(retrieved_docs, query):
             response_parts.append(chunk)
         return ''.join(response_parts)
 
     async def invoke_stream(self, retrieved_docs: List[Dict], query: str) -> AsyncIterator[str]:
+        await self._ensure_client()
         try:
             context = self._format_context(retrieved_docs)
 

backend/app/api/chat.py

@@ -14,7 +14,9 @@
 from ..core.globals import initialize_kernel, get_agent_registry
 from ..auth.middleware import get_current_user
 from ..services.agentic_vector_rag_service import agentic_rag_service
+from ..services.azure_ai_agents_service import azure_ai_agents_service
 from ..services.token_usage_tracker import token_tracker
+from ..services.azure_services import get_azure_service_manager
 
 router = APIRouter()
 
@@ -61,6 +63,15 @@ async def generate():
             if not agentic_rag_service.search_client:
                 await agentic_rag_service.initialize()
 
+            azure_service_manager = await get_azure_service_manager()
+            user_message = {
+                "role": "user",
+                "content": request.prompt,
+                "timestamp": datetime.utcnow().isoformat(),
+                "mode": request.mode
+            }
+            await azure_service_manager.save_session_history(session_id, user_message)
+            
             yield f"data: {json.dumps({'type': 'metadata', 'session_id': session_id, 'mode': request.mode, 'timestamp': datetime.utcnow().isoformat()})}\n\n"
 
             if request.mode == "agentic-rag":
@@ -103,6 +114,16 @@ async def generate():
             }
             yield f"data: {json.dumps({'type': 'metadata', 'processing': processing_metadata})}\n\n"
 
+            assistant_message = {
+                "role": "assistant",
+                "content": answer,
+                "timestamp": datetime.utcnow().isoformat(),
+                "citations": citations,
+                "token_usage": token_usage,
+                "processing_metadata": processing_metadata
+            }
+            await azure_service_manager.save_session_history(session_id, assistant_message)
+            
             yield f"data: {json.dumps({'type': 'done', 'session_id': session_id})}\n\n"
 
         except Exception as e:
@@ -161,9 +182,9 @@ async def process_fast_rag(prompt: str, session_id: str) -> Dict[str, Any]:
             "citations": citations,
             "query_rewrites": [prompt],  # No rewrites in fast mode
             "token_usage": {
-                "prompt_tokens": len(prompt.split()),
-                "completion_tokens": len(answer.split()),
-                "total_tokens": len(prompt.split()) + len(answer.split())
+                "prompt_tokens": 0,  # Fast RAG doesn't use LLM, so no tokens
+                "completion_tokens": 0,
+                "total_tokens": 0
             },
             "processing_time_ms": 0,  # Will be calculated by caller
             "retrieval_method": "fast_rag",
@@ -180,38 +201,34 @@ async def process_fast_rag(prompt: str, session_id: str) -> Dict[str, Any]:
         }
 
 async def process_deep_research_rag(prompt: str, session_id: str, verification_level: str) -> Dict[str, Any]:
-    """Process Deep Research RAG mode with comprehensive verification"""
+    """Process Deep Research RAG mode using Azure AI Agents"""
     try:
-        agentic_result = await agentic_rag_service.process_question(
-            question=prompt,
-            rag_mode="deep-research-rag",
-            session_id=session_id
-        )
-        
-        verification_docs = await retriever.invoke(prompt)
+        from ..services.token_usage_tracker import ServiceType, OperationType
 
-        combined_citations = agentic_result.get("citations", [])
+        tracking_id = token_tracker.start_tracking(
+            session_id=session_id,
+            service_type=ServiceType.DEEP_RESEARCH_RAG,
+            operation_type=OperationType.ANSWER_GENERATION,
+            endpoint="/deep-research-rag",
+            rag_mode="deep-research-rag"
+        )
 
-        for i, doc in enumerate(verification_docs[:2]):  # Add top 2 verification docs
-            combined_citations.append({
-                'id': str(len(combined_citations) + 1),
-                'title': doc.get('title', f'Verification Document {i + 1}'),
-                'content': doc.get('content', '')[:300],
-                'source': doc.get('source', ''),
-                'score': doc.get('score', 0.0),
-                'verification': True
-            })
+        agents_result = await azure_ai_agents_service.process_deep_research(
+            question=prompt,
+            session_id=session_id,
+            tracking_id=tracking_id
+        )
 
-        base_answer = agentic_result.get("answer", "")
-        verification_note = f"\n\n*This response has been enhanced with {verification_level} verification using additional sources.*"
+        base_answer = agents_result.get("answer", "")
+        verification_note = f"\n\n*This response has been generated using Azure AI Agents deep research with {verification_level} verification.*"
 
         return {
             "answer": base_answer + verification_note,
-            "citations": combined_citations,
-            "query_rewrites": agentic_result.get("query_rewrites", [prompt]),
-            "token_usage": agentic_result.get("token_usage", {}),
-            "processing_time_ms": agentic_result.get("processing_time_ms", 0),
-            "retrieval_method": "deep_research_rag",
+            "citations": agents_result.get("citations", []),
+            "query_rewrites": agents_result.get("query_rewrites", [prompt]),
+            "token_usage": agents_result.get("token_usage", {}),
+            "processing_time_ms": 0,  # Will be calculated by caller
+            "retrieval_method": "azure_ai_agents_deep_research",
             "verification_level": verification_level,
             "success": True
         }
@@ -224,3 +241,65 @@ async def process_deep_research_rag(prompt: str, session_id: str, verification_l
             "token_usage": {"total_tokens": 0, "error": str(e)},
             "success": False
         }
+
+@router.get("/chat/sessions/{session_id}/history")
+async def get_session_history(session_id: str, current_user: dict = Depends(get_current_user)):
+    """Get chat session history"""
+    try:
+        azure_service_manager = await get_azure_service_manager()
+        history = await azure_service_manager.get_session_history(session_id)
+        return {"session_id": session_id, "messages": history}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/chat/sessions/{session_id}")
+async def clear_session_history(session_id: str, current_user: dict = Depends(get_current_user)):
+    """Clear chat session history"""
+    try:
+        azure_service_manager = await get_azure_service_manager()
+        empty_session = {
+            "role": "system",
+            "content": "Session cleared",
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        await azure_service_manager.save_session_history(f"{session_id}_cleared", empty_session)
+        return {"session_id": session_id, "status": "cleared"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/chat/sessions")
+async def list_user_sessions(current_user: dict = Depends(get_current_user)):
+    """List all sessions for the current user (placeholder implementation)"""
+    try:
+        return {"sessions": [], "message": "Session listing not yet implemented"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+class FollowUpRequest(BaseModel):
+    original_question: str
+    answer: str
+    session_id: Optional[str] = None
+
+@router.post("/chat/follow-up-questions")
+async def generate_follow_up_questions(request: FollowUpRequest, current_user: dict = Depends(get_current_user)):
+    """Generate follow-up questions based on the original question and answer"""
+    try:
+        session_id = request.session_id or str(uuid.uuid4())
+        
+        if not azure_ai_agents_service.agents_client:
+            await azure_ai_agents_service.initialize()
+        
+        result = await azure_ai_agents_service.generate_follow_up_questions(
+            original_question=request.original_question,
+            answer=request.answer,
+            session_id=session_id
+        )
+        
+        return {
+            "session_id": session_id,
+            "follow_up_questions": result.get("follow_up_questions", []),
+            "token_usage": result.get("token_usage", {}),
+            "success": result.get("success", False)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/app/api/ingest.py

@@ -185,7 +185,7 @@ async def _fallback_processing(self, file_path: str, filename: str, status_callb
                     content=text,
                     source=filename,
                     company="Unknown",
-                    year=2024
+                    year="2024"
                 )
 
                 self.logger.info(f"Using proper chunking, created {len(proper_chunks)} chunks")
@@ -207,7 +207,7 @@ async def _fallback_processing(self, file_path: str, filename: str, status_callb
                 "metadata": {
                     "company": "Unknown",
                     "document_type": "Document", 
-                    "year": 2024,
+                    "year": "2024",
                     "filename": filename,
                     "total_chunks": len(chunks),
                     "content_length": len(text),
@@ -227,7 +227,7 @@ async def _fallback_processing(self, file_path: str, filename: str, status_callb
                 "metadata": {
                     "company": "Unknown",
                     "document_type": "Document",
-                    "year": 2024,
+                    "year": "2024",
                     "filename": filename,
                     "total_chunks": 0,
                     "content_length": 0,
@@ -387,7 +387,7 @@ def status_callback(status_update):
             await asyncio.sleep(0.1)
             status_callback({
                 "step": "RECEIVED",
-                "message": f"📄 File received: {filename} ({file_extension.upper()}) - validating...",
+                "message": f"📄 File received: {file.filename} ({file_extension.upper()}) - validating...",
                 "progress": 3
             })