initial deployment

.cursorrules

@@ -0,0 +1,268 @@
+# FastAPI + Streamlit + Groq Project Setup Rules
+
+## Project Structure
+```
+.
+├── app/
+│   ├── __init__.py
+│   ├── main.py              # FastAPI application
+│   ├── models/             
+│   │   ├── __init__.py
+│   │   └── base.py         # Pydantic models
+│   ├── services/
+│   │   ├── __init__.py
+│   │   └── llm.py         # LLM integration
+│   └── utils/
+│       ├── __init__.py
+│       └── helpers.py      # Utility functions
+├── frontend/
+│   ├── __init__.py
+│   └── app.py             # Streamlit application
+├── data/                  # Data storage
+├── tests/
+│   ├── __init__.py
+│   ├── test_api.py
+│   └── test_services.py
+├── .env                   # Environment variables
+├── .gitignore
+├── README.md
+├── requirements.txt
+└── run.py                # Application entry point
+```
+
+## Required Dependencies
+```python
+# requirements.txt
+fastapi>=0.100.0
+uvicorn>=0.22.0
+pydantic>=2.0.0
+streamlit>=1.25.0
+requests>=2.31.0
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+groq>=0.4.0
+pytest>=7.4.0
+httpx>=0.24.0  # For testing
+```
+
+## Environment Variables
+```bash
+# .env
+GROQ_API_KEY=your-api-key
+ENVIRONMENT=development
+CORS_ORIGINS=["http://localhost:8501"]
+```
+
+## Best Practices
+
+### FastAPI Setup
+```python
+# app/main.py
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+import os
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(
+    title="Your App Name",
+    description="Your app description",
+    version="1.0.0"
+)
+
+# CORS setup
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=json.loads(os.getenv("CORS_ORIGINS", '["http://localhost:8501"]')),
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Error handling
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request, exc):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"detail": exc.detail},
+    )
+```
+
+### Pydantic Models
+```python
+# app/models/base.py
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from datetime import datetime
+from uuid import UUID, uuid4
+
+class BaseModelWithTimestamp(BaseModel):
+    id: UUID = Field(default_factory=uuid4)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+    def model_dump(self, *args, **kwargs):
+        data = super().model_dump(*args, **kwargs)
+        # Convert UUID and datetime to string
+        data['id'] = str(data['id'])
+        data['created_at'] = data['created_at'].isoformat()
+        data['updated_at'] = data['updated_at'].isoformat()
+        return data
+```
+
+### Streamlit Setup
+```python
+# frontend/app.py
+import streamlit as st
+import requests
+from typing import Dict, List
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="Your App Name",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# API client setup
+class APIClient:
+    def __init__(self):
+        self.base_url = os.getenv("API_URL", "http://localhost:8000")
+        
+    def _handle_response(self, response):
+        if response.ok:
+            return response.json()
+        st.error(f"Error: {response.status_code} - {response.text}")
+        return None
+
+    def get(self, endpoint: str):
+        try:
+            response = requests.get(f"{self.base_url}{endpoint}")
+            return self._handle_response(response)
+        except Exception as e:
+            st.error(f"API Error: {str(e)}")
+            return None
+
+api = APIClient()
+```
+
+### LLM Integration
+```python
+# app/services/llm.py
+from groq import Groq
+from dotenv import load_dotenv
+import os
+import json
+from typing import List, Dict, Any
+
+load_dotenv()
+
+class LLMService:
+    def __init__(self):
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise ValueError("GROQ_API_KEY not set")
+        self.client = Groq(api_key=api_key)
+    
+    def _handle_response(self, response_text: str) -> Dict[str, Any]:
+        try:
+            return json.loads(response_text)
+        except json.JSONDecodeError as e:
+            print(f"Error parsing LLM response: {e}")
+            return None
+```
+
+### Data Storage
+```python
+# app/utils/storage.py
+import json
+from pathlib import Path
+from typing import Dict, Any
+from fastapi import HTTPException
+
+class JSONStorage:
+    def __init__(self, file_path: str):
+        self.file_path = Path(file_path)
+        self.file_path.parent.mkdir(exist_ok=True)
+        
+    def read(self) -> Dict[str, Any]:
+        try:
+            if not self.file_path.exists():
+                return {}
+            with open(self.file_path, 'r') as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            return {}
+            
+    def write(self, data: Dict[str, Any]):
+        temp_file = self.file_path.with_suffix('.tmp')
+        try:
+            with open(temp_file, 'w') as f:
+                json.dump(data, f, indent=2)
+            temp_file.replace(self.file_path)
+        except Exception as e:
+            if temp_file.exists():
+                temp_file.unlink()
+            raise HTTPException(status_code=500, detail=str(e))
+```
+
+## Common Issues & Solutions
+
+1. **Environment Variables**
+   - Always use python-dotenv
+   - Check variables at startup
+   - Provide clear error messages
+
+2. **JSON Handling**
+   - Always use try-except for JSON operations
+   - Implement atomic writes
+   - Validate data before saving
+
+3. **API Errors**
+   - Implement proper error handling
+   - Use appropriate HTTP status codes
+   - Return meaningful error messages
+
+4. **LLM Integration**
+   - Handle malformed responses
+   - Implement fallback mechanisms
+   - Cache expensive operations
+
+5. **Frontend**
+   - Show loading states
+   - Handle API errors gracefully
+   - Validate input before submission
+
+6. **Testing**
+   - Write tests for API endpoints
+   - Mock external services
+   - Test error conditions
+
+## Security Considerations
+
+1. **Environment Variables**
+   - Never commit .env files
+   - Use secure secrets management in production
+
+2. **API Security**
+   - Implement rate limiting
+   - Add authentication when needed
+   - Validate all inputs
+
+3. **CORS**
+   - Restrict origins in production
+   - Only allow necessary methods
+   - Handle credentials properly
+
+4. **Data Storage**
+   - Implement backup mechanisms
+   - Use atomic operations
+   - Validate data integrity

.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment Variables
+.env
+.env.*
+
+# Project specific
+data/
+*.log
+.coverage
+htmlcov/ 

CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+## [1.0.0] - Initial Release
+
+### Added
+- Basic FastAPI backend setup with CRUD operations
+- Streamlit frontend with profile creation and viewing
+- JSON-based data storage with atomic writes
+- Basic search functionality
+
+### Bug Fixes
+- Fixed UUID serialization in JSON storage
+- Added proper error handling for file operations
+- Fixed CORS middleware configuration
+
+## [1.1.0] - Groq Integration
+
+### Added
+- Integrated Groq LLM for semantic search
+- Added natural language query processing
+- Enhanced search results with match scores and explanations
+
+### Bug Fixes
+- Fixed environment variable loading for Groq API key
+- Added proper JSON response parsing with fallback
+- Improved error handling in search functionality
+
+### Technical Improvements
+- Added atomic file operations for data storage
+- Implemented proper package structure with __init__.py files
+- Added type hints and documentation
+- Enhanced error messages and user feedback
+
+## Best Practices & Lessons Learned
+
+### Environment Setup
+- Always use python-dotenv for environment variable management
+- Keep .env file in root directory
+- Add .env to .gitignore
+- Document required environment variables in README
+
+### Data Handling
+- Use atomic operations for file writes
+- Always validate JSON before writing
+- Implement proper error handling for file operations
+- Use Pydantic models for data validation
+
+### API Design
+- Implement proper response models
+- Add comprehensive error handling
+- Use proper HTTP status codes
+- Document API endpoints
+
+### Frontend
+- Implement proper form validation
+- Add clear error messages
+- Show loading states
+- Handle API errors gracefully
+
+### Search Functionality
+- Implement fallback search mechanisms
+- Handle malformed LLM responses
+- Provide clear search examples
+- Show detailed match explanations
+
+### Known Issues & Limitations
+- LLM responses might sometimes be inconsistent
+- JSON parsing can fail with malformed LLM output
+- Basic authentication not implemented
+- No rate limiting implemented 

README.md

@@ -10,3 +10,79 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 100xEngineers Discovery Platform 🚀
+
+A platform for discovering and connecting with engineers based on their technical skills, AI expertise, and collaboration interests. Built with FastAPI, Streamlit, and powered by Groq LLM for intelligent profile matching.
+
+## Features
+
+- 👤 Create and manage detailed engineer profiles
+- 🔍 Natural language search powered by Groq LLM
+- 🤝 Find collaborators based on skills and interests
+- 📊 View all registered profiles
+- 🎯 Get detailed match explanations
+
+## Tech Stack
+
+- **Backend**: FastAPI
+- **Frontend**: Streamlit
+- **LLM Integration**: Groq
+- **Data Storage**: JSON with atomic operations
+- **Deployment**: Hugging Face Spaces
+
+## Environment Variables
+
+The following environment variables need to be set in your Hugging Face Space:
+
+- `GROQ_API_KEY`: Your Groq API key
+- `HF_SPACE_URL`: Your Hugging Face Space URL (set automatically)
+- `ENVIRONMENT`: Set to "production" for deployment
+- `CORS_ORIGINS`: List of allowed origins (automatically configured)
+
+## Local Development
+
+1. Clone the repository
+2. Create a virtual environment:
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+3. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+4. Create a `.env` file with required variables
+5. Run the application:
+```bash
+# Terminal 1: Backend
+python run.py
+
+# Terminal 2: Frontend
+streamlit run frontend/app.py
+```
+
+## Deployment
+
+This application is deployed on Hugging Face Spaces. The deployment is configured using the `Spacefile` which sets up both the FastAPI backend and Streamlit frontend services.
+
+## Usage
+
+1. **Create Profile**: Add your engineering profile with skills, expertise, and interests
+2. **Search Profiles**: Use natural language to find matching engineers
+3. **View Matches**: See detailed explanations of why profiles match your search
+4. **Browse All**: View all registered engineer profiles
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+MIT License - feel free to use this project as a template for your own applications!

Spacefile

@@ -0,0 +1,14 @@
+# Spacefile Docs: https://huggingface.co/docs/hub/spaces-config-reference
+configuration:
+  hardware:
+    cpu: 2
+    memory: 16
+  services:
+    - name: fastapi
+      dist: python
+      port: 8000
+      command: uvicorn app.main:app --host 0.0.0.0 --port 8000
+    - name: streamlit
+      dist: python
+      port: 8501
+      command: streamlit run frontend/app.py 

app.py

@@ -1,18 +0,0 @@
-# frontend/app.py
-import streamlit as st
-
-st.set_page_config(
-    page_title="100xEngineers Discovery Platform",
-    layout="centered"
-)
-
-st.title("100xEngineers Discovery Platform")
-
-st.markdown("""
-Welcome to the 100xEngineers Discovery Platform!
-Use the pages on the left to navigate through the app:
-- **🔑 Login** 
-- **✏️ Edit Profile**
-- **🔍 Search**
-- **👤 Profile View**
-""")

app/__init__.py

@@ -0,0 +1,3 @@
+"""
+100xEngineers Discovery Platform - Backend Package
+""" 

app/main.py

@@ -0,0 +1,126 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Dict, Tuple
+from pydantic import BaseModel
+import json
+import os
+from pathlib import Path
+from app.models.user import UserProfile
+from app.services.groq_search import GroqSearchService
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(title="100xEngineers Discovery Platform")
+
+# Initialize Groq service with error handling
+try:
+    groq_search = GroqSearchService()
+except Exception as e:
+    print(f"Warning: Failed to initialize Groq service: {str(e)}")
+    groq_search = None
+
+# CORS middleware setup
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize data storage
+DATA_FILE = Path("data/profiles.json")
+DATA_FILE.parent.mkdir(exist_ok=True)
+
+# Initialize the JSON file if it doesn't exist
+if not DATA_FILE.exists():
+    with open(DATA_FILE, "w") as f:
+        json.dump({}, f)
+
+def load_profiles() -> Dict[str, UserProfile]:
+    try:
+        with open(DATA_FILE, "r") as f:
+            try:
+                data = json.load(f)
+                return {k: UserProfile(**v) for k, v in data.items()}
+            except json.JSONDecodeError:
+                # If file is corrupted, start fresh
+                return {}
+    except FileNotFoundError:
+        # Create file if it doesn't exist
+        with open(DATA_FILE, "w") as f:
+            json.dump({}, f)
+        return {}
+
+def save_profiles(profiles: Dict[str, UserProfile]):
+    # Create directory if it doesn't exist
+    DATA_FILE.parent.mkdir(exist_ok=True)
+    
+    # Write to a temporary file first
+    temp_file = DATA_FILE.with_suffix('.tmp')
+    try:
+        with open(temp_file, "w") as f:
+            # Use model_dump() which now handles UUID conversion
+            json.dump({k: v.model_dump() for k, v in profiles.items()}, f, indent=2)
+        
+        # Rename temp file to actual file (atomic operation)
+        temp_file.replace(DATA_FILE)
+    except Exception as e:
+        if temp_file.exists():
+            temp_file.unlink()  # Delete temp file if it exists
+        raise HTTPException(status_code=500, detail=str(e))
+
+# API endpoints
+@app.post("/api/profiles", response_model=UserProfile)
+async def create_profile(profile: UserProfile):
+    profiles = load_profiles()
+    profile_id = str(profile.id)
+    profiles[profile_id] = profile
+    save_profiles(profiles)
+    return profile
+
+@app.get("/api/profiles", response_model=List[UserProfile])
+async def list_profiles():
+    profiles = load_profiles()
+    return list(profiles.values())
+
+@app.get("/api/profiles/{profile_id}", response_model=UserProfile)
+async def get_profile(profile_id: str):
+    profiles = load_profiles()
+    if profile_id not in profiles:
+        raise HTTPException(status_code=404, detail="Profile not found")
+    return profiles[profile_id]
+
+# Update SearchResponse model
+class SearchResponse(BaseModel):
+    profile: UserProfile
+    explanation: str
+
+class SearchQuery(BaseModel):
+    query: str
+
+@app.post("/api/search", response_model=List[SearchResponse])
+async def search_profiles(search: SearchQuery):
+    profiles = load_profiles()
+    
+    if not groq_search:
+        # Fallback to basic search if Groq is not available
+        results = []
+        query = search.query.lower()
+        for profile in profiles.values():
+            if (query in profile.name.lower() or
+                any(query in skill.lower() for skill in profile.technical_skills) or
+                any(query in expertise.lower() for expertise in profile.ai_expertise) or
+                query in profile.mentoring_preferences.lower()):
+                results.append((profile, "Basic match based on keyword search"))
+        return [SearchResponse(profile=profile, explanation=explanation) 
+                for profile, explanation in results]
+    
+    # Use Groq for semantic search
+    matches = groq_search.search_profiles(search.query, list(profiles.values()))
+    
+    # Convert to response format
+    return [SearchResponse(profile=profile, explanation=explanation) 
+            for profile, explanation in matches] 

app/models/__init__.py

@@ -0,0 +1,3 @@
+"""
+100xEngineers Discovery Platform - Models Package
+""" 

app/models/user.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field, HttpUrl, AnyHttpUrl
+from typing import List, Optional
+from uuid import UUID, uuid4
+
+class UserProfile(BaseModel):
+    id: UUID = Field(default_factory=uuid4)
+    name: str = Field(..., min_length=2, max_length=100)
+    technical_skills: List[str] = Field(default_factory=list)
+    projects: List[str] = Field(default_factory=list)
+    ai_expertise: List[str] = Field(default_factory=list)
+    mentoring_preferences: str = Field(..., min_length=10, max_length=500)
+    collaboration_interests: List[str] = Field(default_factory=list)
+    portfolio_url: Optional[str] = None
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "name": "John Doe",
+                "technical_skills": ["Python", "FastAPI", "Machine Learning"],
+                "projects": ["AI Chatbot", "Web Scraping Tool"],
+                "ai_expertise": ["NLP", "Computer Vision"],
+                "mentoring_preferences": "Available for weekly 1-hour sessions, focusing on AI and backend development",
+                "collaboration_interests": ["Open Source", "AI Projects"],
+                "portfolio_url": "https://github.com/johndoe"
+            }
+        }
+        
+    def model_dump(self, *args, **kwargs):
+        data = super().model_dump(*args, **kwargs)
+        # Convert UUID to string
+        data['id'] = str(data['id'])
+        return data 

app/services/groq_search.py

@@ -0,0 +1,171 @@
+import os
+from typing import List, Dict, Tuple
+from groq import Groq
+from app.models.user import UserProfile
+from dotenv import load_dotenv
+import json
+
+# Load environment variables from .env file
+load_dotenv()
+
+class GroqSearchService:
+    def __init__(self):
+        api_key = os.getenv("GROQ_API_KEY")
+        if not api_key:
+            raise ValueError("GROQ_API_KEY environment variable is not set")
+            
+        self.client = Groq(
+            api_key=api_key,
+        )
+        
+    def _create_profile_context(self, profile: UserProfile) -> str:
+        """Create a searchable context string from a profile."""
+        return f"""
+Name: {profile.name}
+Technical Skills: {', '.join(profile.technical_skills)}
+Projects: {', '.join(profile.projects)}
+AI Expertise: {', '.join(profile.ai_expertise)}
+Mentoring Preferences: {profile.mentoring_preferences}
+Collaboration Interests: {', '.join(profile.collaboration_interests)}
+"""
+
+    def search_profiles(self, query: str, profiles: List[UserProfile]) -> List[Tuple[UserProfile, str]]:
+        """
+        Search profiles using Groq LLM and return matches with explanations.
+        Returns: List of tuples (profile, explanation)
+        """
+        if not profiles:
+            return []
+
+        # Create context from all profiles
+        profile_contexts = {str(p.id): self._create_profile_context(p) for p in profiles}
+        
+        # Create the prompt for Groq
+        prompt = f"""You are an expert at matching engineers based on their profiles. Your task is to find the most relevant profiles that match the given search query.
+
+Search Query: "{query}"
+
+Available Engineer Profiles:
+{'-' * 80}
+"""
+        for pid, context in profile_contexts.items():
+            prompt += f"\nProfile ID: {pid}\n{context}\n{'-' * 80}"
+
+        prompt += """\nInstructions:
+1. Analyze the search query and understand the key requirements.
+2. Compare these requirements against each profile's skills, expertise, and preferences.
+3. For each matching profile, calculate a match score (0-100) based on:
+   - Direct skill matches
+   - Related expertise
+   - Project experience
+   - Mentoring alignment
+   - Collaboration potential
+
+Return your analysis in the following JSON format:
+[
+  {
+    "profile_id": "exact-profile-uuid-from-above",
+    "match_score": number-between-0-and-100,
+    "explanation": "Detailed explanation of why this profile matches the search query"
+  }
+]
+
+Important:
+- Include ANY profile that has relevant matches, even if the match score is moderate
+- Be lenient with matching - if someone has related skills, they might be a good fit
+- The explanation should be specific about why the profile matches
+- Sort results by match_score in descending order
+- Return an empty list [] if truly no profiles match
+
+Remember: It's better to show more potential matches than to be too restrictive."""
+
+        # Get response from Groq
+        try:
+            chat_completion = self.client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are an expert at matching engineers based on their profiles. You always return valid JSON in the exact format requested."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt,
+                    }
+                ],
+                model="llama3-8b-8192",
+                temperature=0.2,  # Slightly higher temperature for more inclusive matching
+                max_tokens=2000,
+            )
+            
+            response_text = chat_completion.choices[0].message.content.strip()
+            
+            # Try to extract JSON if it's wrapped in backticks or has extra text
+            try:
+                # First try direct JSON parsing
+                matches = json.loads(response_text)
+            except json.JSONDecodeError:
+                # Try to extract JSON from the response
+                import re
+                json_match = re.search(r'\[[\s\S]*\]', response_text)
+                if json_match:
+                    try:
+                        matches = json.loads(json_match.group(0))
+                    except json.JSONDecodeError:
+                        print(f"Failed to parse Groq response: {response_text}")
+                        return self._fallback_search(query, profiles)
+                else:
+                    print(f"No JSON found in response: {response_text}")
+                    return self._fallback_search(query, profiles)
+            
+            # Convert to list of tuples (profile, explanation)
+            results = []
+            for match in matches:
+                profile_id = match.get("profile_id")
+                explanation = match.get("explanation", "")
+                score = match.get("match_score", 0)
+                
+                # Find the profile with this ID
+                profile = next((p for p in profiles if str(p.id) == profile_id), None)
+                if profile:
+                    results.append((profile, f"Match Score: {score}%\n{explanation}"))
+            
+            # If no matches found through Groq, try fallback search
+            if not results:
+                return self._fallback_search(query, profiles)
+                
+            return results
+                
+        except Exception as e:
+            print(f"Error during Groq search: {str(e)}")
+            return self._fallback_search(query, profiles)
+
+    def _fallback_search(self, query: str, profiles: List[UserProfile]) -> List[Tuple[UserProfile, str]]:
+        """Fallback to basic keyword matching if Groq search fails."""
+        results = []
+        query_terms = query.lower().split()
+        
+        for profile in profiles:
+            score = 0
+            matches = []
+            
+            # Check each field for matches
+            profile_text = self._create_profile_context(profile).lower()
+            
+            for term in query_terms:
+                if term in profile_text:
+                    score += 1
+                    # Find which field matched
+                    if term in profile.name.lower():
+                        matches.append(f"Name matches '{term}'")
+                    if any(term in skill.lower() for skill in profile.technical_skills):
+                        matches.append(f"Has technical skill related to '{term}'")
+                    if any(term in exp.lower() for exp in profile.ai_expertise):
+                        matches.append(f"Has AI expertise related to '{term}'")
+                    if term in profile.mentoring_preferences.lower():
+                        matches.append(f"Mentoring preferences match '{term}'")
+            
+            if score > 0:
+                explanation = "Basic Match:\n" + "\n".join(matches)
+                results.append((profile, explanation))
+        
+        return sorted(results, key=lambda x: len(x[1].split('\n')), reverse=True) 

frontend/app.py

@@ -0,0 +1,219 @@
+import streamlit as st
+import requests
+from typing import Dict, List
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="100xEngineers Discovery Platform",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# API client setup
+class APIClient:
+    def __init__(self):
+        # Get the Hugging Face Space URL from environment or use localhost
+        space_url = os.getenv("HF_SPACE_URL")
+        if space_url:
+            # In Hugging Face Spaces, the FastAPI service will be available at port 8000
+            self.base_url = f"https://{space_url}-8000.hf.space"
+        else:
+            # Local development
+            self.base_url = "http://localhost:8000"
+        
+        st.sidebar.text(f"API URL: {self.base_url}")
+        
+    def _handle_response(self, response):
+        if response.ok:
+            return response.json()
+        st.error(f"Error: {response.status_code} - {response.text}")
+        return None
+
+    def get(self, endpoint: str):
+        try:
+            response = requests.get(f"{self.base_url}{endpoint}")
+            return self._handle_response(response)
+        except Exception as e:
+            st.error(f"API Error: {str(e)}")
+            return None
+
+api = APIClient()
+
+def create_profile(profile_data: dict):
+    # Validate and clean the data before sending
+    if profile_data.get("portfolio_url"):
+        url = profile_data["portfolio_url"].strip()
+        if not (url.startswith("http://") or url.startswith("https://")):
+            url = f"https://{url}"
+        try:
+            # Basic URL validation
+            if not url.replace("https://", "").replace("http://", ""):
+                profile_data.pop("portfolio_url", None)
+            else:
+                profile_data["portfolio_url"] = url
+        except Exception:
+            profile_data.pop("portfolio_url", None)
+    else:
+        profile_data.pop("portfolio_url", None)
+    
+    try:
+        response = requests.post(f"{api.base_url}/api/profiles", json=profile_data)
+        if response.status_code == 422:
+            error_detail = response.json().get('detail', [])
+            if isinstance(error_detail, list):
+                for error in error_detail:
+                    st.error(f"Validation Error: {error.get('msg')}")
+            else:
+                st.error(f"Validation Error: {error_detail}")
+            return None
+        elif not response.ok:
+            st.error(f"Server Error: {response.status_code}")
+            return None
+        return response.json()
+    except requests.exceptions.ConnectionError:
+        st.error("Could not connect to the server. Please make sure the backend is running.")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+        return None
+
+def search_profiles(query: str):
+    try:
+        response = requests.post(
+            f"{api.base_url}/api/search",
+            json={"query": query}  # Send query in correct format
+        )
+        if not response.ok:
+            if response.status_code == 422:
+                st.error("Invalid search query format")
+            else:
+                st.error(f"Search failed with status code: {response.status_code}")
+            return []
+        return response.json()
+    except requests.exceptions.ConnectionError:
+        st.error("Could not connect to the server. Please make sure the backend is running.")
+        return []
+    except Exception as e:
+        st.error(f"An unexpected error occurred during search: {str(e)}")
+        return []
+
+def list_profiles():
+    try:
+        response = requests.get(f"{api.base_url}/api/profiles")
+        if not response.ok:
+            st.error(f"Failed to fetch profiles: {response.status_code}")
+            return []
+        return response.json()
+    except requests.exceptions.ConnectionError:
+        st.error("Could not connect to the server. Please make sure the backend is running.")
+        return []
+    except Exception as e:
+        st.error(f"An unexpected error occurred while fetching profiles: {str(e)}")
+        return []
+
+# UI Components
+st.title("100xEngineers Discovery Platform 🚀")
+
+# Sidebar navigation
+page = st.sidebar.radio("Navigation", ["Search Profiles", "Create Profile", "View All Profiles"])
+
+if page == "Create Profile":
+    st.header("Create Your Profile")
+    
+    with st.form("profile_form"):
+        name = st.text_input("Name", help="Enter your full name (minimum 2 characters)")
+        technical_skills = st.text_input("Technical Skills (comma-separated)", 
+                                       help="Enter your technical skills, separated by commas")
+        projects = st.text_input("Projects (comma-separated)",
+                               help="List your notable projects, separated by commas")
+        ai_expertise = st.text_input("AI Expertise (comma-separated)",
+                                   help="List your AI-related skills and expertise")
+        mentoring_preferences = st.text_area("Mentoring Preferences",
+                                           help="Describe your mentoring preferences (minimum 10 characters)")
+        collaboration_interests = st.text_input("Collaboration Interests (comma-separated)",
+                                              help="List your interests for collaboration")
+        portfolio_url = st.text_input("Portfolio URL",
+                                    help="Enter your portfolio URL (optional)")
+        
+        submitted = st.form_submit_button("Create Profile")
+        
+        if submitted:
+            if len(name.strip()) < 2:
+                st.error("Name must be at least 2 characters long")
+            elif len(mentoring_preferences.strip()) < 10:
+                st.error("Mentoring preferences must be at least 10 characters long")
+            else:
+                profile_data = {
+                    "name": name.strip(),
+                    "technical_skills": [s.strip() for s in technical_skills.split(",") if s.strip()],
+                    "projects": [p.strip() for p in projects.split(",") if p.strip()],
+                    "ai_expertise": [a.strip() for a in ai_expertise.split(",") if a.strip()],
+                    "mentoring_preferences": mentoring_preferences.strip(),
+                    "collaboration_interests": [c.strip() for c in collaboration_interests.split(",") if c.strip()],
+                    "portfolio_url": portfolio_url.strip() if portfolio_url.strip() else None
+                }
+                
+                if profile := create_profile(profile_data):
+                    st.success("Profile created successfully!")
+                    st.json(profile)
+
+elif page == "Search Profiles":
+    st.header("Search Profiles")
+    
+    st.markdown("""
+    Search for engineers using natural language. Examples:
+    - "Find someone experienced in machine learning and NLP"
+    - "Looking for a mentor in backend development"
+    - "Need a collaborator for an open source AI project"
+    """)
+    
+    query = st.text_input("Enter your search query in natural language")
+    
+    if query:
+        results = search_profiles(query)
+        
+        if results:
+            st.subheader(f"Found {len(results)} matches")
+            for result in results:
+                profile = result['profile']
+                explanation = result['explanation']
+                
+                with st.expander(f"{profile['name']}"):
+                    # Display match explanation
+                    st.markdown(f"**Match Analysis:**\n{explanation}")
+                    st.markdown("---")
+                    
+                    # Display profile details
+                    st.write("**Technical Skills:**", ", ".join(profile["technical_skills"]))
+                    st.write("**AI Expertise:**", ", ".join(profile["ai_expertise"]))
+                    st.write("**Projects:**", ", ".join(profile["projects"]))
+                    st.write("**Mentoring Preferences:**", profile["mentoring_preferences"])
+                    st.write("**Collaboration Interests:**", ", ".join(profile["collaboration_interests"]))
+                    if profile.get("portfolio_url"):
+                        st.write("**Portfolio:**", profile["portfolio_url"])
+        else:
+            st.info("No matching profiles found. Try adjusting your search query.")
+
+else:  # View All Profiles
+    st.header("All Profiles")
+    
+    profiles = list_profiles()
+    
+    if profiles:
+        for profile in profiles:
+            with st.expander(f"{profile['name']}"):
+                st.write("**Technical Skills:**", ", ".join(profile["technical_skills"]))
+                st.write("**AI Expertise:**", ", ".join(profile["ai_expertise"]))
+                st.write("**Projects:**", ", ".join(profile["projects"]))
+                st.write("**Mentoring Preferences:**", profile["mentoring_preferences"])
+                st.write("**Collaboration Interests:**", ", ".join(profile["collaboration_interests"]))
+                if profile.get("portfolio_url"):
+                    st.write("**Portfolio:**", profile["portfolio_url"])
+    else:
+        st.info("No profiles found. Create one to get started!") 

requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.2
+streamlit==1.29.0
+requests==2.31.0
+python-multipart==0.0.6
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+python-dotenv==1.0.0
+groq==0.4.2
+python-dotenv==1.0.0 

run.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="127.0.0.1", port=8000, reload=True)