🔧 Update main.py to change MCP server flag, add Hugging Face dependencies in pyproject.toml, and enhance LLM service with Hugging Face integration. Add new job listings and user profiles in JSON data files.

data/profiles.json

@@ -17,5 +17,59 @@
     "certifications": null,
     "created_at": "2025-06-07 15:09:40.290202",
     "updated_at": "2025-06-07 15:09:40.290541"
+  },
+  "demo_user1": {
+    "user_id": "demo_user1",
+    "resume": "AI engineer with experience in NLP, computer vision, and legal AI systems. Skilled in building RAG-based assistants, deploying FastAPI services, and optimizing ML models.",
+    "skills": [
+      "Python",
+      "FastAPI",
+      "Hugging Face Transformers",
+      "OpenPose",
+      "Deep SORT",
+      "Docker",
+      "PostgreSQL",
+      "Bash",
+      "Claude",
+      "Gemini",
+      "YOLO",
+      "Pandas",
+      "NumPy"
+    ],
+    "salary_wish": "$30,000 - $50,000 annually",
+    "career_goals": "Grow as an AI engineer by working on real-world AI applications, especially legal and vision-based systems. Open to research or applied ML roles that help improve model reliability and deployment pipelines.",
+    "experience_level": "Entry-level",
+    "location": "Yerevan / Remote",
+    "education": "BS in Artificial Intelligence (in progress, 2023\u20132027), National Polytechnic University of Armenia",
+    "certifications": null,
+    "created_at": "2025-06-08 00:48:18.790480",
+    "updated_at": "2025-06-08 00:48:18.790482"
+  },
+  "Tatul's_profile": {
+    "user_id": "Tatul's_profile",
+    "resume": "AI engineer with experience in NLP, computer vision, and legal AI systems. Skilled in building RAG-based assistants, deploying FastAPI services, and optimizing ML models.",
+    "skills": [
+      "Python",
+      "FastAPI",
+      "Hugging Face Transformers",
+      "OpenPose",
+      "Deep SORT",
+      "Docker",
+      "PostgreSQL",
+      "Bash",
+      "Claude",
+      "Gemini",
+      "YOLO",
+      "Pandas",
+      "NumPy"
+    ],
+    "salary_wish": "$30,000 - $50,000 annually",
+    "career_goals": "Grow as an AI engineer by working on real-world AI applications, especially legal and vision-based systems. Open to research or applied ML roles that help improve model reliability and deployment pipelines.",
+    "experience_level": "Entry-level",
+    "location": "Yerevan / Remote",
+    "education": "BS in Artificial Intelligence (in progress, 2023\u20132027), National Polytechnic University of Armenia",
+    "certifications": null,
+    "created_at": "2025-06-08 00:48:36.150851",
+    "updated_at": "2025-06-08 00:48:36.150854"
   }
 }

main.py

@@ -420,10 +420,10 @@ def main():
     demo.launch(
         server_name=mcp_server.settings.host,
         server_port=mcp_server.settings.port,
-        enable_mcp=True,
+        mcp_server=True,
         share=False,
-        show_error=True,
-    )
+        show_error=True
+        )
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -26,6 +26,7 @@ dependencies = [
     "aiohttp>=3.8.0",
     "typing-extensions>=4.5.0",
     "pydantic-settings>=2.9.1",
+    "huggingface-hub>=0.32.4",
 ]
 
 [project.optional-dependencies]

src/config/settings.py

@@ -3,10 +3,14 @@
 import os
 from functools import lru_cache
 from typing import Optional
+from dotenv import load_dotenv
 
 from pydantic import Field
 from pydantic_settings import BaseSettings
 
+# Load environment variables from .env file
+load_dotenv()
+
 
 class Settings(BaseSettings):
     """Application settings and configuration."""
@@ -14,6 +18,7 @@ class Settings(BaseSettings):
     # API Keys
     openai_api_key: Optional[str] = Field(default=None, env="OPENAI_API_KEY")
     anthropic_api_key: Optional[str] = Field(default=None, env="ANTHROPIC_API_KEY")
+    hf_access_token: Optional[str] = Field(default=None, env="HF_ACCESS_TOKEN")
 
     # Job Search APIs
     linkedin_api_key: Optional[str] = Field(default=None, env="LINKEDIN_API_KEY")
@@ -30,8 +35,13 @@ class Settings(BaseSettings):
     embedding_dimension: int = Field(default=384, env="EMBEDDING_DIMENSION")
 
     # LLM Settings
-    llm_provider: str = Field(default="openai", env="LLM_PROVIDER")  # openai, anthropic
-    llm_model: str = Field(default="gpt-3.5-turbo", env="LLM_MODEL")
+    llm_provider: str = Field(
+        default="huggingface", env="LLM_PROVIDER"
+    )  # openai, anthropic, huggingface
+    llm_model: str = Field(default="deepseek/deepseek-v3-turbo", env="LLM_MODEL")
+    hf_inference_provider: str = Field(
+        default="novita", env="HF_INFERENCE_PROVIDER"
+    )  # novita, together, fireworks, etc.
     max_tokens: int = Field(default=300, env="MAX_TOKENS")
     temperature: float = Field(default=0.7, env="TEMPERATURE")
 
@@ -66,4 +76,14 @@ class Settings(BaseSettings):
 @lru_cache()
 def get_settings() -> Settings:
     """Get cached settings instance."""
-    return Settings()
+    settings = Settings()
+
+    # Debug print the HF token
+    if settings.hf_access_token:
+        print(
+            f"🔑 HF Access Token loaded: {settings.hf_access_token[:20]}...{settings.hf_access_token[-10:]}"
+        )
+    else:
+        print("❌ No HF Access Token found in environment variables")
+
+    return settings

src/services/llm_service.py

@@ -3,6 +3,8 @@
 from typing import Dict, Any, Optional
 import openai
 from anthropic import Anthropic
+import requests
+import json
 
 from ..config import get_settings
 from .profile_service import UserProfile
@@ -15,6 +17,7 @@ class LLMService:
         self.settings = get_settings()
         self.openai_client = None
         self.anthropic_client = None
+        self.hf_client = None
         self._initialize_clients()
 
     def _initialize_clients(self):
@@ -26,12 +29,29 @@ class LLMService:
         if self.settings.anthropic_api_key:
             self.anthropic_client = Anthropic(api_key=self.settings.anthropic_api_key)
 
+        if self.settings.hf_access_token:
+            # Use the new Inference Providers API
+            self.hf_client = {
+                "api_url": f"https://router.huggingface.co/{self.settings.hf_inference_provider}/v3/openai/chat/completions",
+                "headers": {
+                    "Authorization": f"Bearer {self.settings.hf_access_token}",
+                    "Content-Type": "application/json",
+                },
+            }
+            print(
+                f"🚀 HuggingFace Inference Providers initialized with {self.settings.hf_inference_provider} provider"
+            )
+
     def _get_client(self):
         """Get the appropriate LLM client based on provider setting."""
-        if self.settings.llm_provider == "openai" and self.openai_client:
+        if self.settings.llm_provider == "huggingface" and self.hf_client:
+            return self.hf_client, "huggingface"
+        elif self.settings.llm_provider == "openai" and self.openai_client:
             return self.openai_client, "openai"
         elif self.settings.llm_provider == "anthropic" and self.anthropic_client:
             return self.anthropic_client, "anthropic"
+        elif self.hf_client:
+            return self.hf_client, "huggingface"
         elif self.openai_client:
             return self.openai_client, "openai"
         elif self.anthropic_client:
@@ -81,13 +101,81 @@ class LLMService:
             print(f"Anthropic API error: {e}")
             return None
 
+    def _call_huggingface(
+        self, messages: list, max_tokens: int = None
+    ) -> Optional[str]:
+        """Call HuggingFace Inference Providers API."""
+        try:
+            # Use OpenAI-compatible format for Inference Providers
+            payload = {
+                "model": self.settings.llm_model,
+                "messages": messages,
+                "max_tokens": max_tokens or self.settings.max_tokens,
+                "temperature": self.settings.temperature,
+                "stream": False,
+            }
+
+            print(
+                f"🔄 Calling HF Inference Providers API with {self.settings.hf_inference_provider} provider..."
+            )
+            print(f"📡 URL: {self.hf_client['api_url']}")
+            print(f"🤖 Model: {self.settings.llm_model}")
+
+            response = requests.post(
+                self.hf_client["api_url"],
+                headers=self.hf_client["headers"],
+                json=payload,
+                timeout=60,
+            )
+
+            print(f"📊 Response status: {response.status_code}")
+
+            if response.status_code == 200:
+                result = response.json()
+                print(f"✅ Success: {result}")
+
+                # Handle OpenAI-compatible response format
+                if "choices" in result and len(result["choices"]) > 0:
+                    content = result["choices"][0]["message"]["content"]
+                    return content.strip()
+                else:
+                    print(f"❌ Unexpected response format: {result}")
+                    return None
+            else:
+                error_detail = response.text
+                print(
+                    f"❌ HuggingFace Inference Providers API error: {response.status_code} - {error_detail}"
+                )
+
+                # Try to parse error details
+                try:
+                    error_json = response.json()
+                    if "error" in error_json:
+                        print(f"🔍 Error details: {error_json['error']}")
+                except:
+                    pass
+
+                return None
+
+        except requests.exceptions.Timeout:
+            print(f"⏱️ HuggingFace API timeout error")
+            return None
+        except Exception as e:
+            print(f"❌ HuggingFace API error: {e}")
+            return None
+
     def generate_text(self, messages: list, max_tokens: int = None) -> Optional[str]:
         """Generate text using the configured LLM."""
         client, provider = self._get_client()
         if not client:
+            print("❌ No LLM client available")
             return None
 
-        if provider == "openai":
+        print(f"🎯 Using {provider} provider for text generation")
+
+        if provider == "huggingface":
+            return self._call_huggingface(messages, max_tokens)
+        elif provider == "openai":
             return self._call_openai(messages, max_tokens)
         elif provider == "anthropic":
             return self._call_anthropic(messages, max_tokens)
@@ -130,10 +218,10 @@ JOB DESCRIPTION:
 
 CANDIDATE PROFILE:
 - Skills: {skills_text}
-- Experience: {profile.experience_level or 'Not specified'}
+- Experience: {profile.experience_level or "Not specified"}
 - Career Goals: {profile.career_goals}
-- Location: {profile.location or 'Not specified'}
-- Education: {profile.education or 'Not specified'}
+- Location: {profile.location or "Not specified"}
+- Education: {profile.education or "Not specified"}
 
 RESUME SUMMARY:
 {profile.resume[:1000]}  # Limit resume text
@@ -202,7 +290,7 @@ CONTEXT: {context}
 
 CANDIDATE BACKGROUND:
 - Skills: {", ".join(profile.skills[:8])}
-- Experience Level: {profile.experience_level or 'Not specified'}
+- Experience Level: {profile.experience_level or "Not specified"}
 - Career Goals: {profile.career_goals}
 - Key Background: {profile.resume[:800]}
 

uv.lock

@@ -886,6 +886,7 @@ dependencies = [
     { name = "faiss-cpu" },
     { name = "gradio", extra = ["mcp"] },
     { name = "httpx" },
+    { name = "huggingface-hub" },
     { name = "lxml" },
     { name = "numpy" },
     { name = "openai" },
@@ -922,6 +923,7 @@ requires-dist = [
     { name = "flake8", marker = "extra == 'dev'", specifier = ">=6.0.0" },
     { name = "gradio", extras = ["mcp"], specifier = ">=5.0.0" },
     { name = "httpx", specifier = ">=0.24.0" },
+    { name = "huggingface-hub", specifier = ">=0.32.4" },
     { name = "isort", marker = "extra == 'dev'", specifier = ">=5.12.0" },
     { name = "lxml", specifier = ">=4.9.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.0.0" },