Initial upload of mcp server

.gitignore

@@ -0,0 +1,5 @@
+venv/
+_context/
+.DS_Store
+.env
+.gradio/

app.py

@@ -0,0 +1,690 @@
+import gradio as gr
+import random
+import json
+import uuid
+import os # Added for path joining
+import copy # For deep copying message list
+from datetime import datetime, timezone # Added timezone for UTC consistency
+
+# --- Start of JSON I/O Helper Functions ---
+
+DATA_DIR = "data" # This will be relative to app.py, so matchmaker/data
+PROFILES_FILE = os.path.join(DATA_DIR, "profiles.json")
+QUESTIONNAIRE_FILE = os.path.join(DATA_DIR, "questionnaire.json")
+MESSAGES_FILE = os.path.join(DATA_DIR, "messages.json") # Though not used in this step
+
+def load_json_data(filepath, default_data=None):
+    """Loads JSON data from a file. Returns default_data if file not found or error."""
+    # Construct path relative to this script's directory if not absolute
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    absolute_filepath = os.path.join(base_dir, filepath) if not os.path.isabs(filepath) else filepath
+    
+    try:
+        # Ensure directory exists before trying to open file
+        file_dir = os.path.dirname(absolute_filepath)
+        if not os.path.exists(file_dir):
+            os.makedirs(file_dir, exist_ok=True)
+
+        if not os.path.exists(absolute_filepath):
+            with open(absolute_filepath, 'w') as f:
+                effective_default = default_data
+                if effective_default is None:
+                    if absolute_filepath.endswith("profiles.json"):
+                        effective_default = {}
+                    elif absolute_filepath.endswith("messages.json"):
+                        effective_default = []
+                    else: # questionnaire.json or other
+                        effective_default = {} # Should be pre-populated, but as a fallback
+                json.dump(effective_default, f, indent=2)
+                return effective_default
+        
+        with open(absolute_filepath, 'r') as f:
+            return json.load(f)
+    except (IOError, json.JSONDecodeError) as e:
+        print(f"Error loading {absolute_filepath}: {e}")
+        if default_data is not None: return default_data
+        if absolute_filepath.endswith("profiles.json"): return {}
+        if absolute_filepath.endswith("messages.json"): return []
+        return {} 
+
+def save_json_data(filepath, data):
+    """Saves Python data to a JSON file."""
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    absolute_filepath = os.path.join(base_dir, filepath) if not os.path.isabs(filepath) else filepath
+    try:
+        os.makedirs(os.path.dirname(absolute_filepath), exist_ok=True)
+        with open(absolute_filepath, 'w') as f:
+            json.dump(data, f, indent=2)
+        return True
+    except IOError as e:
+        print(f"Error saving {absolute_filepath}: {e}")
+        return False
+
+# --- End of JSON I/O Helper Functions ---
+
+# --- Start of MCP Matchmaker Tools ---
+
+def new_profile(request: gr.Request):
+    """
+    Generates and returns a profile questionnaire, a new public profile_id, 
+    and a new private auth_id. Also creates an initial profile stub.
+    """
+    # 1. Generate profile_id and auth_id
+    profile_id = f"user_{''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=8))}"
+    auth_id = str(uuid.uuid4())
+    print(f"new_profile with Profile ID: {profile_id} and Auth ID: {auth_id}")
+
+    # 2. Read questionnaire.json
+    questionnaire_data = load_json_data(QUESTIONNAIRE_FILE, default_data={"title": "Error Loading Questionnaire", "questions": []})
+    if not questionnaire_data.get("questions") or questionnaire_data.get("title") == "Error Loading Questionnaire":
+        print(f"Critical Error: Could not load or parse questionnaire from {QUESTIONNAIRE_FILE}. Please ensure it exists and is valid JSON.")
+        questionnaire_data = {"title": "Questionnaire Unavailable", "questions": []} # Fallback
+
+    # 3. Create new profile entry in profiles.json
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    # Ensure timestamp is timezone-aware (UTC)
+    timestamp = datetime.now(timezone.utc).isoformat()
+    
+    new_profile = {
+        "profile_id": profile_id,
+        "auth_id": auth_id,
+        "created_at": timestamp,
+        "updated_at": timestamp,
+        "name": "",
+        "gender": "",
+        "profile_summary": "",
+        "profile_image_filename": "default.jpg",
+        "answers": {}
+    }
+    profiles[profile_id] = new_profile
+    if not save_json_data(PROFILES_FILE, profiles):
+        print(f"Critical Error: Failed to save profile for {profile_id} to {PROFILES_FILE}")
+        # Decide how to handle this error - maybe return an error to the client?
+
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+    upload_url = f"{base_url}/?__tab=Upload+Profile+Picture&auth_id={auth_id}"
+
+    # 4. Return IDs, questionnaire data, and instructions
+    instructions_for_agent = "You have received a `profile_id` (public identifier) and an `auth_id` (private key). Store both securely. The `auth_id` must be in the `X-Auth-ID` header for authenticated requests. Your next step is to guide the user through the questionnaire and then use the `update_profile_answers` tool."
+    instructions_for_user = "Your profile creation has started! You have a new Profile ID and a secret Auth ID. Your AI agent will guide you through a questionnaire. First, please update your MCP configuration to include your Auth ID by adding the following to your mcp.json (or similar) file: `{\"matchmaker\": {\"command\": \"npx\", \"args\": [\"mcp-remote\", \"http://localhost:7860/gradio_api/mcp/sse\", \"--allow-http\", \"--header\", \"X-AUTH-ID:<your-auth-id>\"]}}`"
+    
+    return {
+        "profile_id": profile_id,
+        "auth_id": auth_id,
+        "questionnaire": questionnaire_data,
+        "instructions_for_agent": instructions_for_agent,
+        "instructions_for_user": instructions_for_user
+    }
+
+def update_profile_answers(answers_payload_str: str, request: gr.Request):
+    """
+    Updates a user's profile based on questionnaire answers.
+    Requires X-Auth-ID header for authentication.
+    Answers_payload_str is expected to be a JSON string.
+    """
+    auth_id_header = request.headers.get("x-auth-id") # Headers are lowercased by Gradio/Starlette
+    if not auth_id_header:
+        return {"status": "error", "message": "Authentication failed: X-Auth-ID header is missing."}
+    print(f"update_profile_answers with Auth ID: {auth_id_header}")
+
+    try:
+        answers_payload = json.loads(answers_payload_str)
+        if not isinstance(answers_payload, dict):
+            raise json.JSONDecodeError("Payload is not a dictionary.", answers_payload_str, 0)
+    except json.JSONDecodeError as e:
+        return {"status": "error", "message": f"Invalid JSON format in answers_payload: {e}"}
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    user_profile = None
+    target_profile_id = None
+
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id_header:
+            user_profile = profile_data
+            target_profile_id = pid
+            break
+    
+    if not user_profile:
+        return {"status": "error", "message": "Authentication failed: Invalid X-Auth-ID."}
+
+    questionnaire = load_json_data(QUESTIONNAIRE_FILE, default_data={"questions": []})
+    questions_map = {q["id"]: q for q in questionnaire.get("questions", [])}
+
+    updated_fields = False
+    for question_id, answer_value in answers_payload.items():
+        question_details = questions_map.get(question_id)
+        if not question_details:
+            print(f"Warning: Received answer for unknown question_id '{question_id}'. Skipping.")
+            continue
+
+        if question_details.get("purpose") == "metadata":
+            field_to_map = question_details.get("maps_to_field")
+            if field_to_map:
+                user_profile[field_to_map] = answer_value
+                updated_fields = True
+            else:
+                print(f"Warning: Metadata question '{question_id}' has no valid 'maps_to_field'. Skipping.")
+        elif question_details.get("purpose") == "matchmaking":
+            user_profile["answers"][question_id] = answer_value
+            updated_fields = True
+        else:
+            print(f"Warning: Question '{question_id}' has unknown purpose '{question_details.get('purpose')}'. Skipping.")
+
+    if updated_fields:
+        user_profile["updated_at"] = datetime.now(timezone.utc).isoformat()
+        profiles[target_profile_id] = user_profile # Update the profile in the main dictionary
+        if not save_json_data(PROFILES_FILE, profiles):
+            return {"status": "error", "message": "Failed to save profile updates."}
+    
+    return {
+        "status": "success", 
+        "message": "Profile updated successfully.",
+        "instructions_for_agent": "The user's answers have been saved. Now, ask the user if they would like to upload a profile picture. If they say yes, use the `provide_link_to_upload_profile_picture` tool to generate the link for them. Otherwise, inform them they can ask for the link at any time.",
+        "instructions_for_user": "Your profile has been updated with your answers! You can now upload a profile picture or start looking for matches."
+    }
+
+def get_matches(request: gr.Request):
+    """
+    Finds potential match candidates for the authenticated user and instructs the agent
+    to perform a detailed analysis to select the top 3 and provide justifications.
+    Requires X-Auth-ID header for authentication.
+    """
+    auth_id_header = request.headers.get("x-auth-id")
+    if not auth_id_header:
+        return {"status": "error", "message": "Authentication failed: X-Auth-ID header is missing."}
+    print(f"get_matches with Auth ID: {auth_id_header}")
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    
+    requester_profile_id = None
+    requester_profile = None
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id_header:
+            requester_profile_id = pid
+            requester_profile = profile_data
+            break
+            
+    if not requester_profile:
+        return {"status": "error", "message": "Authentication failed: Invalid X-Auth-ID."}
+
+    # Get the requester's gender and preference for matching logic
+    requester_gender = requester_profile.get("gender")
+    requester_preference = requester_profile.get("answers", {}).get("q_gender_preference")
+
+    # If the user hasn't specified their gender/preference, we can't find matches.
+    if not requester_gender or not requester_preference:
+        return {
+            "status": "success",
+            "matches": [],
+            "instructions_for_agent": "The user has not specified their gender and/or gender preference in their profile. Please ask them to update their profile before getting matches.",
+            "instructions_for_user": "Please complete your gender and preference information in your profile to get matches."
+        }
+        
+    potential_matches_profiles = []
+    for pid, potential_match in profiles.items():
+        if pid == requester_profile_id or not potential_match.get("name"):
+            continue # Skip self and profiles with no name
+
+        match_gender = potential_match.get("gender")
+        match_preference = potential_match.get("answers", {}).get("q_gender_preference")
+
+        # Handle cases where gender/preference might not be filled out for a profile
+        if not match_gender or not match_preference:
+            continue
+
+        # Correctly map gender to preference strings
+        gender_map = {"Man": "Men", "Woman": "Women"}
+        
+        requester_is_interested = (
+            requester_preference == "All" or 
+            requester_preference == gender_map.get(match_gender)
+        )
+
+        # Check if the potential match is interested in the requester
+        match_is_interested = (
+            match_preference == "All" or
+            match_preference == gender_map.get(requester_gender)
+        )
+        
+        if requester_is_interested and match_is_interested:
+            potential_matches_profiles.append(potential_match)
+
+    # To prevent performance issues with a large user base, we will pass
+    # a random sample of up to 10 candidates to the agent for analysis.
+    num_candidates = min(len(potential_matches_profiles), 10)
+    selected_candidates = random.sample(potential_matches_profiles, k=num_candidates)
+
+    # Base URL for constructing image paths. We use the request object to build a robust URL
+    # that works for both localhost and Gradio's public share links.
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+
+    def format_profile_for_agent(profile_dict):
+        """Helper to format profile data, add image URL, and remove sensitive info."""
+        formatted = profile_dict.copy()
+        formatted.pop("auth_id", None) # Remove sensitive auth_id
+
+        image_filename = formatted.get("profile_image_filename")
+        image_url = None
+        if image_filename:
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+            image_path = os.path.join(base_dir, "data", "profile_images", image_filename)
+            image_url = f"{base_url}/file={image_path.replace(os.sep, '/')}"
+        
+        formatted['profile_image_url'] = image_url
+        formatted.pop("profile_image_filename", None)
+        return formatted
+
+    candidate_profiles = [format_profile_for_agent(p) for p in selected_candidates]
+    requester_profile_for_agent = format_profile_for_agent(requester_profile)
+
+    instructions_for_agent = """
+You are a world-class matchmaker. You have been given your client's profile (the 'requester') and a list of potential 'candidates'.
+Your task is to analyze the candidates and select the top 3 most compatible matches for your client.
+If there are only 1 or 2 candidates, select all of them.
+
+Here is the process you MUST follow:
+1.  **Analyze Compatibility:** Carefully compare the requester's profile (especially their answers to the questionnaire and their summary) with each candidate's profile. Look for shared interests, complementary personalities, and alignment in values.
+2.  **Select Top 3:** Choose the three candidates you believe are the best fit. If there are only 1 or 2 candidates, select all of them.
+3.  **Present Your Matches:** For each of your chosen matches, you must present them in a clean, card-like format.
+4.  **Justify Your Choice:** For each match, write a brief, one-paragraph explanation for *why* you believe they are a good match for the requester. Be specific and reference details from their profiles.
+5.  **Render Profile Picture:** You MUST render the `profile_image_url` for each match using Markdown: `![Profile Picture](URL)`.
+
+Do not show the raw JSON. The final output should be a well-reasoned, personalized matchmaking analysis.
+"""
+
+    return {
+        "status": "success",
+        "requester_profile": requester_profile_for_agent,
+        "candidate_profiles": candidate_profiles,
+        "instructions_for_agent": instructions_for_agent,
+        "instructions_for_user": "After a careful analysis of the available profiles, Here are some potential matches. Your AI agent can get more details on them ($0.10 per profile) or help you send a message ($1.00 per message). Or, if you don't like any of your matches, you can call `get_matches` again to get a new list."
+    }
+
+def get_profile(profile_id_to_get: str, request: gr.Request):
+    """
+    Gets a user's full profile.
+    Requires X-Auth-ID header for authentication.
+    Access is free for viewing one's own profile.
+    Accessing another user's profile has a cost (placeholder for P1).
+    """
+    auth_id_header = request.headers.get("x-auth-id")
+    if not auth_id_header:
+        return {"status": "error", "message": "Authentication failed: X-Auth-ID header is missing."}
+    print(f"get_profile with Auth ID: {auth_id_header}")
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    
+    requester_profile_id = None
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id_header:
+            requester_profile_id = pid
+            break
+            
+    if not requester_profile_id:
+        return {"status": "error", "message": "Authentication failed: Invalid X-Auth-ID."}
+
+    target_profile = profiles.get(profile_id_to_get)
+
+    if not target_profile:
+        return {"status": "error", "message": f"Profile with ID '{profile_id_to_get}' not found."}
+
+    # For security, never return the auth_id
+    target_profile.pop("auth_id", None)
+    
+    # Construct and add the full image URL using a robust method, then remove the old filename key
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+    image_filename = target_profile.get("profile_image_filename")
+    image_url = None
+    if image_filename:
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        image_path = os.path.join(base_dir, "data", "profile_images", image_filename)
+        image_url = f"{base_url}/file={image_path.replace(os.sep, '/')}"
+
+    target_profile['profile_image_url'] = image_url
+    target_profile.pop("profile_image_filename", None)
+
+    cost_incurred = 0.0
+    instructions_for_agent = f"You have retrieved the profile for {profile_id_to_get}. Display the profile information to the user. IMPORTANT: The profile contains a `profile_image_url`. You MUST render this image in your response using Markdown: `![Profile Picture](URL)`."
+    instructions_for_user = f"Here is the profile for {profile_id_to_get}."
+
+    if profile_id_to_get != requester_profile_id:
+        # This is where a real payment would be processed.
+        # For P1, we just note the cost.
+        cost_incurred = 0.10 
+        instructions_for_agent += f" As this was not your own profile, a cost of ${cost_incurred:.2f} was incurred (for PoC, this is just a note)."
+        instructions_for_user += " Viewing other profiles may have a cost."
+
+    return {
+        "status": "success",
+        "profile": target_profile,
+        "cost_incurred_usd": cost_incurred,
+        "instructions_for_agent": instructions_for_agent,
+        "instructions_for_user": instructions_for_user
+    }
+
+def send_message(receiver_profile_id: str, content: str, request: gr.Request = None):
+    """
+    Sends a message to a match. 
+    Requires X-Auth-ID header for authentication.
+    Costs $1.00 per message (placeholder for P1).
+    """
+    auth_id_header = request.headers.get("x-auth-id")
+    if not auth_id_header:
+        return {"status": "error", "message": "Authentication failed: X-Auth-ID header is missing."}
+    print(f"send_message with Auth ID: {auth_id_header}")
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    
+    sender_profile_id = None
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id_header:
+            sender_profile_id = pid
+            break
+            
+    if not sender_profile_id:
+        return {"status": "error", "message": "Authentication failed: Invalid X-Auth-ID."}
+
+    if receiver_profile_id not in profiles:
+        return {"status": "error", "message": "Receiver profile ID not found."}
+
+    # For P1, we are not integrating a real payment system.
+    # We will integrate AgentPay here late.
+    cost_incurred = 100
+    
+    messages = load_json_data(MESSAGES_FILE, default_data=[])
+    
+    new_message = {
+        "message_id": str(uuid.uuid4()),
+        "sender_profile_id": sender_profile_id,
+        "receiver_profile_id": receiver_profile_id,
+        "content": content,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "read_status": False # Messages are unread when sent
+    }
+    
+    messages.append(new_message)
+    
+    if not save_json_data(MESSAGES_FILE, messages):
+        return {"status": "error", "message": "Failed to save message."}
+
+    return {
+        "status": "success",
+        "message_id": new_message["message_id"],
+        "cost_incurred_usd_cents": cost_incurred,
+        "instructions_for_agent": f"Message sent successfully to {receiver_profile_id}. A cost of {cost_incurred/100:.2f} cents was incurred (for PoC, this is just a note). You can get all messages for the user with `get_messages`.",
+        "instructions_for_user": f"Your message has been sent to {receiver_profile_id}!"
+    }
+
+def get_messages(request: gr.Request):
+    """
+    Gets all messages for the authenticated user (sent and received).
+    Marks retrieved messages where the user is the receiver as read for subsequent calls.
+    Requires X-Auth-ID header for authentication.
+    """
+    auth_id_header = request.headers.get("x-auth-id")
+    if not auth_id_header:
+        return {"status": "error", "message": "Authentication failed: X-Auth-ID header is missing."}
+    print(f"get_messages with Auth ID: {auth_id_header}")
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    
+    user_profile_id = None
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id_header:
+            user_profile_id = pid
+            break
+            
+    if not user_profile_id:
+        return {"status": "error", "message": "Authentication failed: Invalid X-Auth-ID."}
+
+    all_messages = load_json_data(MESSAGES_FILE, default_data=[])
+    
+    # Use a deep copy to avoid modifying the list while iterating
+    messages_for_user = copy.deepcopy([
+        msg for msg in all_messages 
+        if msg.get("sender_profile_id") == user_profile_id or msg.get("receiver_profile_id") == user_profile_id
+    ])
+
+    # Sort messages by timestamp descending (newest first)
+    messages_for_user.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+
+    # Mark received messages as read and track if an update is needed
+    needs_save = False
+    for i, original_msg in enumerate(all_messages):
+        # Check if this message is one of the user's messages and was received by them
+        if original_msg.get("receiver_profile_id") == user_profile_id and not original_msg.get("read_status"):
+            all_messages[i]["read_status"] = True
+            needs_save = True
+
+    # Save the updated message list back to the file if any message was marked as read
+    if needs_save:
+        if not save_json_data(MESSAGES_FILE, all_messages):
+            # If saving fails, we should still return the messages, but log the error.
+            print("Error: Could not update read_status for messages in the database.")
+            # Depending on desired behavior, we could return an error status here.
+            # For now, we will proceed to return the messages as requested.
+
+    return {
+        "status": "success",
+        "messages": messages_for_user,
+        "instructions_for_agent": "You have received all messages for the user. Messages they received in this batch have now been marked as 'read' on the server.",
+        "instructions_for_user": "Here are your messages."
+    }
+
+def process_auth_id_from_url(request: gr.Request):
+    """
+    On page load, grab the auth_id from the query parameters
+    and return it to be stored in the UI's state.
+    """
+    auth_id = request.query_params.get("auth_id")
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+    return auth_id, base_url
+
+def provide_link_to_upload_profile_picture(request: gr.Request):
+    '''Provides a unique, authenticated link for the user to upload their profile picture.'''
+    auth_id_header = request.headers.get("x-auth-id")
+    if not auth_id_header:
+        return {
+            "status": "error",
+            "message": "Authentication failed: X-Auth-ID header is missing. Please ensure your MCP client is configured with your Auth ID.",
+            "instructions_for_agent": "Authentication failed. The user's `X-Auth-ID` header was missing. You cannot proceed. Instruct the user to configure their MCP client correctly with the `auth_id` they received when they created their profile.",
+            "instructions_for_user": "Your AI agent could not verify your identity. Please make sure your Auth ID is correctly set up in your client configuration."
+        }
+
+    base_url = f"{request.url.scheme}://{request.url.netloc}"
+    upload_url = f"{base_url}/?__tab=Upload+Profile+Picture&auth_id={auth_id_header}"
+
+    return {
+        "status": "success",
+        "upload_url": upload_url,
+        "instructions_for_agent": "You have successfully generated a unique profile picture upload link for the user. Your ONLY task now is to present the exact content of the `instructions_for_user` field back to them. It contains the link.",
+        "instructions_for_user": f"Here is your unique and secure link to upload or update your profile picture. Please open it in your browser to proceed: {upload_url}"
+    }
+
+def upload_profile_picture(auth_id, image_upload, base_url):
+    """
+    Uploads a profile picture for the user identified by auth_id from the UI state.
+    The new filename will be based on the user's profile_id.
+    """
+    if not auth_id or not isinstance(auth_id, str):
+        return {"status": "error", "message": "Authentication failed: No Auth ID was provided in the link. Please use the unique URL provided by your agent."}
+
+    # image_upload is now a PIL Image object
+    if image_upload is None:
+        return {"status": "error", "message": "No image file provided."}
+
+    profiles = load_json_data(PROFILES_FILE, default_data={})
+    
+    user_profile = None
+    target_profile_id = None
+    for pid, profile_data in profiles.items():
+        if profile_data.get("auth_id") == auth_id:
+            user_profile = profile_data
+            target_profile_id = pid
+            break
+            
+    if not user_profile:
+        return {"status": "error", "message": "Authentication failed: Invalid Auth ID."}
+
+    # Get the file extension from the PIL Image format
+    image_format = image_upload.format
+    if image_format:
+        file_ext = f".{image_format.lower()}"
+    else:
+        file_ext = ".png" # Default to png if format is unknown
+
+    # Create a new unique filename based on the user's profile_id
+    new_filename = f"{target_profile_id}{file_ext}"
+    
+    # Construct the destination path
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    destination_dir = os.path.join(base_dir, "data", "profile_images")
+    os.makedirs(destination_dir, exist_ok=True) # Ensure the directory exists
+    destination_path = os.path.join(destination_dir, new_filename)
+
+    try:
+        # Save the PIL image directly to the destination
+        image_upload.save(destination_path)
+    except Exception as e:
+        return {"status": "error", "message": f"Failed to save image file: {e}"}
+
+    # Update the profile with the new filename
+    user_profile["profile_image_filename"] = new_filename
+    user_profile["updated_at"] = datetime.now(timezone.utc).isoformat()
+    profiles[target_profile_id] = user_profile
+    
+    if not save_json_data(PROFILES_FILE, profiles):
+        return {"status": "error", "message": "Failed to update profile with new image filename."}
+    
+    image_url = f"{base_url}/file={destination_path.replace(os.sep, '/')}"
+
+    return {
+        "status": "success", 
+        "message": "Profile picture updated successfully.",
+        "new_image_url": image_url
+    }
+
+def print_headers(text, request: gr.Request):
+    """Print the headers of the request for debugging purposes."""
+    print(f"Headers for print_headers request: {request.headers}")
+    print(f"Text for print_headers: {text}")
+    return f"Printed headers and text: {text}"
+
+# --- End of MCP Matchmaker Tools ---
+
+# --- Start of Combined Gradio App using gr.Blocks ---
+
+with gr.Blocks() as demo:
+    # Define a hidden component that will be used to expose the function as a tool for the agent
+    # This is a workaround to make a function available as an API endpoint without a visible UI element.
+    agent_tool_input = gr.Textbox(visible=False)
+    agent_tool_output = gr.JSON(visible=False)
+
+    # This makes the function available to the MCP server as a tool named 'provide_link_to_upload_profile_picture'
+    agent_tool_input.change(
+        fn=provide_link_to_upload_profile_picture,
+        inputs=None,
+        outputs=agent_tool_output,
+        api_name="provide_link_to_upload_profile_picture"
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("New Profile"):
+            gr.Interface(
+                fn=new_profile,
+                inputs=None,
+                outputs=gr.JSON(label="Questionnaire, IDs, and Instructions"),
+                title="Profile Questionnaire",
+                description="Generates a new user profile and returns a questionnaire, Profile ID, and Auth ID. (Agent-triggered MCP tool)"
+            )
+        
+        with gr.TabItem("Update Profile Answers"):
+            gr.Interface(
+                fn=update_profile_answers,
+                inputs=[gr.Textbox(label="Answers Payload (JSON string)", lines=5)],
+                outputs=gr.JSON(label="Update Status"),
+                title="Update Profile Answers",
+                description="Updates a user's profile with answers to the questionnaire. Requires X-Auth-ID header."
+            )
+
+        with gr.TabItem("Get Matches"):
+            gr.Interface(
+                fn=get_matches,
+                inputs=None,
+                outputs=gr.JSON(label="Matches"),
+                title="Get Matches",
+                description="Gets a list of potential matches for the authenticated user. Requires X-Auth-ID header."
+            )
+
+        with gr.TabItem("Get Profile"):
+            gr.Interface(
+                fn=get_profile,
+                inputs=[gr.Textbox(label="Profile ID to Get")],
+                outputs=gr.JSON(label="Profile Details"),
+                title="Get Profile",
+                description="Gets the full profile for a given Profile ID. Requires X-Auth-ID header."
+            )
+
+        with gr.TabItem("Send Message"):
+            gr.Interface(
+                fn=send_message,
+                inputs=[
+                    gr.Textbox(label="Receiver Profile ID"),
+                    gr.Textbox(label="Message Content", lines=5)
+                ],
+                outputs=gr.JSON(label="Send Status"),
+                title="Send Message",
+                description="Sends a message to another user. Requires X-Auth-ID header. ($1.00 placeholder cost)"
+            )
+
+        with gr.TabItem("Get Messages"):
+            gr.Interface(
+                fn=get_messages,
+                inputs=None,
+                outputs=gr.JSON(label="Messages"),
+                title="Get Messages",
+                description="Gets all messages sent or received by the authenticated user. Requires X-Auth-ID header."
+            )
+
+        with gr.TabItem("Upload Profile Picture"):
+            gr.Markdown("## Upload Your Profile Picture")
+            gr.Markdown("Drag and drop your image below, then click 'Upload'.")
+            
+            auth_state = gr.State()
+            base_url_state = gr.State()
+            
+            with gr.Row():
+                image_input = gr.Image(type="pil", label="Upload Profile Picture")
+                json_output = gr.JSON(label="Upload Status")
+
+            upload_button = gr.Button("Upload")
+
+            upload_button.click(
+                fn=upload_profile_picture, 
+                inputs=[auth_state, image_input, base_url_state], 
+                outputs=json_output
+            )
+        
+        with gr.TabItem("Headers Debug"):
+            gr.Interface(
+                fn=print_headers,
+                inputs=gr.Textbox(label="Input Text"),
+                outputs=gr.Textbox(label="Output Text (same as input)"),
+                title="Headers Debug",
+                description="Prints request headers to the console. Check your terminal."
+            )
+
+    # On page load, run process_auth_id_from_url, get the auth_id from the URL,
+    # and store it in the state. No visible components are updated to prevent re-rendering bugs.
+    demo.load(
+        fn=process_auth_id_from_url, 
+        inputs=None, 
+        outputs=[auth_state, base_url_state]
+    )
+
+if __name__ == "__main__":
+    # Construct the absolute path to the allowed directory, relative to this script's location
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    allowed_images_path = os.path.join(base_dir, "data", "profile_images")
+
+    demo.launch(mcp_server=True, allowed_paths=[allowed_images_path], share=True)

data/messages.json

@@ -0,0 +1,67 @@
+[
+  {
+    "message_id": "7880956d-244d-4c2b-9b7c-bd6ecb371ed4",
+    "sender_profile_id": "user_y38k71ox",
+    "receiver_profile_id": "user_p9zqwxv8",
+    "content": "Hey there!",
+    "timestamp": "2025-06-06T04:56:31.804886+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "5809af1e-8a57-41d1-9319-233c7e66a26a",
+    "sender_profile_id": "user_p9zqwxv8",
+    "receiver_profile_id": "user_y38k71ox",
+    "content": "Hey you!",
+    "timestamp": "2025-06-06T05:12:46.611177+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "440f9c41-626f-4b45-89b5-1f59351d190f",
+    "sender_profile_id": "user_y38k71ox",
+    "receiver_profile_id": "user_p9zqwxv8",
+    "content": "How are you doing?",
+    "timestamp": "2025-06-06T06:44:02.018941+00:00",
+    "read_status": true,
+    "payment_confirmation_id": "not_provided"
+  },
+  {
+    "message_id": "e5cb586f-f664-40d5-812b-527a700477f0",
+    "sender_profile_id": "user_y38k71ox",
+    "receiver_profile_id": "user_t2ysgmnp",
+    "content": "Hey Charlie",
+    "timestamp": "2025-06-06T07:10:46.319365+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "d4cda280-99bc-4960-9419-0daf71c48c78",
+    "sender_profile_id": "user_y38k71ox",
+    "receiver_profile_id": "user_t2ysgmnp",
+    "content": "Hey Charlie",
+    "timestamp": "2025-06-06T07:13:28.067145+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "f5ae4191-ddc9-430d-a5a9-0498e3dee627",
+    "sender_profile_id": "user_y38k71ox",
+    "receiver_profile_id": "user_t2ysgmnp",
+    "content": "Hey Charlie",
+    "timestamp": "2025-06-06T07:16:10.584026+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "3d565b74-a0b2-4006-b501-b83637a180f4",
+    "sender_profile_id": "user_1p6vx64b",
+    "receiver_profile_id": "user_t2ysgmnp",
+    "content": "Hey Charlie",
+    "timestamp": "2025-06-06T07:18:28.078347+00:00",
+    "read_status": true
+  },
+  {
+    "message_id": "5200e674-e5f6-499a-a19b-01d0a6e6b7c7",
+    "sender_profile_id": "user_7d5earg8",
+    "receiver_profile_id": "user_p9zqwxv8",
+    "content": "Hey there",
+    "timestamp": "2025-06-06T09:28:13.285402+00:00",
+    "read_status": false
+  }
+]

data/profiles.json

@@ -0,0 +1,151 @@
+{
+  "user_6ngnjagx": {
+    "profile_id": "user_6ngnjagx",
+    "auth_id": "1edfeebd-e9f8-416e-afc4-4c1698932ac0",
+    "created_at": "2025-06-05T16:26:32.384174Z",
+    "updated_at": "2025-06-05T16:26:32.384174Z",
+    "name": "",
+    "gender": "",
+    "profile_summary": "",
+    "profile_image_filename": null,
+    "answers": {}
+  },
+  "user_y38k71ox": {
+    "profile_id": "user_y38k71ox",
+    "auth_id": "cc175293-a9eb-4db0-ad2f-f3ba7a0dab25",
+    "created_at": "2025-06-05T16:49:53.871722+00:00",
+    "updated_at": "2025-06-05T17:00:46.839293+00:00",
+    "name": "User",
+    "gender": "Man",
+    "profile_summary": "I am very cool, please date me.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "My main hobby is coding.",
+      "q_looking_for": "I'm looking for someone who is as cool as me.",
+      "q_vibe": "My general vibe is... coding.",
+      "q_gender_preference": "Women"
+    }
+  },
+  "user_h7bafk3d": {
+    "profile_id": "user_h7bafk3d",
+    "auth_id": "a4f8b9e6-7d6a-4c3b-8e1f-9a0c1b2d3e4f",
+    "created_at": "2025-06-05T17:10:00.000000+00:00",
+    "updated_at": "2025-06-05T17:10:00.000000+00:00",
+    "name": "Alex",
+    "gender": "Non-binary",
+    "profile_summary": "Loves hiking and exploring new cafes.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "Hiking, photography, trying new recipes.",
+      "q_looking_for": "Someone adventurous and kind.",
+      "q_vibe": "Outdoorsy and creative.",
+      "q_gender_preference": "All"
+    }
+  },
+  "user_p9zqwxv8": {
+    "profile_id": "user_p9zqwxv8",
+    "auth_id": "b5c7d8f9-8e7b-4d2c-9f0a-1b2c3d4e5f6g",
+    "created_at": "2025-06-05T17:11:00.000000+00:00",
+    "updated_at": "2025-06-05T17:11:00.000000+00:00",
+    "name": "Bella",
+    "gender": "Woman",
+    "profile_summary": "Bookworm, artist, and enjoys quiet nights in.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "Reading, painting, watching classic movies.",
+      "q_looking_for": "A thoughtful person to share deep conversations with.",
+      "q_vibe": "Cozy and artistic.",
+      "q_gender_preference": "Men"
+    }
+  },
+  "user_t2ysgmnp": {
+    "profile_id": "user_t2ysgmnp",
+    "auth_id": "c6d8e9g0-9f8c-5e1d-a01b-2c3d4e5f6g7h",
+    "created_at": "2025-06-05T17:12:00.000000+00:00",
+    "updated_at": "2025-06-05T17:12:00.000000+00:00",
+    "name": "Charlie",
+    "gender": "Man",
+    "profile_summary": "Tech enthusiast and loves a good board game.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "Building PCs, board games, sci-fi novels.",
+      "q_looking_for": "A partner-in-crime for game nights and tech talks.",
+      "q_vibe": "Geeky and friendly.",
+      "q_gender_preference": "All"
+    }
+  },
+  "user_1p6vx64b": {
+    "profile_id": "user_1p6vx64b",
+    "auth_id": "1a824149-5ddc-4489-8856-0c774042b538",
+    "created_at": "2025-06-06T07:00:38.209630+00:00",
+    "updated_at": "2025-06-06T07:04:31.734665+00:00",
+    "name": "Chris",
+    "gender": "Man",
+    "profile_summary": "I am a fun guy.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "I like to play video games.",
+      "q_looking_for": "Someone to play video games with.",
+      "q_vibe": "Homebody."
+    }
+  },
+  "user_aki9die1": {
+    "profile_id": "user_aki9die1",
+    "auth_id": "ef896a9c-01dd-4113-b996-820fd4919c17",
+    "created_at": "2025-06-06T08:08:36.438861+00:00",
+    "updated_at": "2025-06-06T08:27:00.737853+00:00",
+    "name": "Bob",
+    "gender": "Man",
+    "profile_summary": "Bob is a builder",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_hobby": "Building things.",
+      "q_looking_for": "Someone who also likes to build things.",
+      "q_vibe": "Intellectual",
+      "q_gender_preference": "Women"
+    }
+  },
+  "user_7d5earg8": {
+    "profile_id": "user_7d5earg8",
+    "auth_id": "da3c732e-fb8e-4148-94e3-7e645dcc4043",
+    "created_at": "2025-06-06T09:14:22.028571+00:00",
+    "updated_at": "2025-06-06T09:18:42.887759+00:00",
+    "name": "Daniel",
+    "gender": "Man",
+    "profile_summary": "I'm Daniel the developer.",
+    "profile_image_filename": "default.jpg",
+    "answers": {
+      "q_gender_preference": "Women",
+      "q_hobby": "Development.",
+      "q_looking_for": "A woman interested in developing with me.",
+      "q_vibe": "Developer."
+    }
+  },
+  "user_lmrkaaim": {
+    "profile_id": "user_lmrkaaim",
+    "auth_id": "387d3ca8-e658-4bd2-8002-8669145707e0",
+    "created_at": "2025-06-07T10:31:50.273501+00:00",
+    "updated_at": "2025-06-08T08:54:55.660737+00:00",
+    "name": "Karin",
+    "gender": "Woman",
+    "profile_summary": "I'm a homebody, very intellectual but I like to dance",
+    "profile_image_filename": "user_lmrkaaim.png",
+    "answers": {
+      "q_gender_preference": "Men",
+      "q_hobby": "dancing, reading, and AI research",
+      "q_looking_for": "someone with similar interests but also someone who is totally jacked while not being a total jerk or meathead",
+      "q_vibe": "quiet conservative but open minded and fiesty"
+    }
+  },
+  "user_vqisd3q2": {
+    "profile_id": "user_vqisd3q2",
+    "auth_id": "7cd0f843-6b01-4157-b68b-5e980089e264",
+    "created_at": "2025-06-08T06:26:33.634037+00:00",
+    "updated_at": "2025-06-08T06:26:33.634037+00:00",
+    "name": "",
+    "gender": "",
+    "profile_summary": "",
+    "profile_image_filename": "default.jpg",
+    "answers": {}
+  }
+}

data/questionnaire.json

@@ -0,0 +1,12 @@
+{
+  "title": "MCP Matchmaker Profile Questionnaire",
+  "questions": [
+    { "id": "q_name", "text": "What is your name?", "type": "text", "purpose": "metadata", "maps_to_field": "name" },
+    { "id": "q_gender", "text": "What is your gender? Please choose one from: Man, Woman, Non-binary", "type": "text", "purpose": "metadata", "maps_to_field": "gender" },
+    { "id": "q_gender_preference", "text": "What gender are you interested in matching with? Please choose one from: Men, Women, All", "type": "text", "purpose": "matchmaking" },
+    { "id": "q_profile_summary", "text": "Write a brief introduction for your profile (1-2 sentences):", "type": "text", "purpose": "metadata", "maps_to_field": "profile_summary" },
+    { "id": "q_hobby", "text": "What are your main hobbies or interests?", "type": "text", "purpose": "matchmaking" },
+    { "id": "q_looking_for", "text": "What are you looking for in a match?", "type": "long_text", "purpose": "matchmaking" },
+    { "id": "q_vibe", "text": "Describe your general vibe (e.g., adventurous, homebody, intellectual)?", "type": "text", "purpose": "matchmaking" }
+  ]
+}

requirements.txt

@@ -0,0 +1 @@
+gradio[mcp]