Recommends personalized gifts based on recipient’s social media cues Go

```python
# This is a simplified example and would require significant expansion to be a fully functional gift recommendation system.
# It uses dummy data and basic string matching to demonstrate the concept.  In reality, you'd need to integrate with social media APIs,
# use more sophisticated NLP techniques, and potentially machine learning models.

import json

# Dummy data for recipient profiles based on potential social media cues
recipient_profiles = {
    "Alice": {
        "interests": ["hiking", "photography", "national parks", "dogs"],
        "posts": ["Just hiked to the top of Mount Something! Amazing views.", "My dog, Bailey, is the best!", "Looking forward to my next photography adventure."],
        "likes": ["National Geographic", "REI", "Dog Magazine"]
    },
    "Bob": {
        "interests": ["gaming", "sci-fi", "coding", "space"],
        "posts": ["Just finished coding a cool new app!", "Excited for the new Star Wars movie!", "Playing the latest RPG all weekend."],
        "likes": ["Steam", "NASA", "Reddit's r/gaming"]
    },
    "Charlie": {
        "interests": ["cooking", "gardening", "baking", "italian food"],
        "posts": ["Made a delicious lasagna tonight!", "My garden is finally starting to bloom.", "Trying out a new sourdough recipe."],
        "likes": ["Food Network", "Bon Appetit", "Martha Stewart"]
    }
}

# Dummy data for gift options
gift_catalog = {
    "Hiking Kit": {
        "tags": ["hiking", "outdoors", "adventure"],
        "description": "A complete kit for your next hiking adventure."
    },
    "Photography Lens": {
        "tags": ["photography", "camera", "image"],
        "description": "A high-quality lens for capturing stunning photos."
    },
    "Dog Toy": {
        "tags": ["dogs", "pets", "toys"],
        "description": "A fun and durable toy for your furry friend."
    },
    "Gaming Headset": {
        "tags": ["gaming", "headphones", "audio"],
        "description": "Immerse yourself in your favorite games with this headset."
    },
    "Sci-Fi Book": {
        "tags": ["sci-fi", "books", "reading"],
        "description": "A thrilling science fiction novel."
    },
    "Coding Bootcamp Voucher": {
        "tags": ["coding", "programming", "learning"],
        "description": "Learn to code with this online bootcamp voucher."
    },
    "Pasta Maker": {
        "tags": ["cooking", "italian", "pasta"],
        "description": "Make fresh pasta at home with this machine."
    },
    "Gardening Tools": {
        "tags": ["gardening", "plants", "outdoors"],
        "description": "Essential tools for any gardener."
    }
}

def recommend_gifts(recipient_name):
    """
    Recommends personalized gifts based on the recipient's social media profile.

    Args:
        recipient_name: The name of the recipient.

    Returns:
        A list of recommended gifts, sorted by relevance score.
    """

    if recipient_name not in recipient_profiles:
        return "Recipient not found in database."

    profile = recipient_profiles[recipient_name]
    interests = profile["interests"]
    posts = profile["posts"]
    likes = profile["likes"]

    recommendations = []

    for gift_name, gift_data in gift_catalog.items():
        relevance_score = 0
        tags = gift_data["tags"]

        # Calculate relevance score based on matching interests and tags
        for interest in interests:
            if interest in tags:
                relevance_score += 2  # Higher score for direct interest match

        # Calculate relevance score based on keywords in posts
        for post in posts:
            for tag in tags:
                if tag in post.lower():  # Case-insensitive match
                    relevance_score += 1

        # Calculate relevance score based on likes (very rudimentary)
        for like in likes:
            for tag in tags:
                if tag in like.lower():
                    relevance_score += 0.5 #Lower score as likes are less direct indicators

        if relevance_score > 0:  # Only consider gifts with some relevance
            recommendations.append((gift_name, relevance_score))

    # Sort recommendations by relevance score in descending order
    recommendations.sort(key=lambda x: x[1], reverse=True)  # Sort by score (x[1])

    # Format the output
    recommended_gifts = []
    for gift_name, score in recommendations:
        recommended_gifts.append(f"{gift_name} (Relevance: {score})")

    return recommended_gifts

# Example usage
recipient = "Alice"
recommendations = recommend_gifts(recipient)

if isinstance(recommendations, str):
    print(recommendations)  # Print the error message
else:
    print(f"Recommended gifts for {recipient}:")
    for gift in recommendations:
        print(gift)

recipient = "Bob"
recommendations = recommend_gifts(recipient)

if isinstance(recommendations, str):
    print(recommendations)  # Print the error message
else:
    print(f"Recommended gifts for {recipient}:")
    for gift in recommendations:
        print(gift)

recipient = "Charlie"
recommendations = recommend_gifts(recipient)

if isinstance(recommendations, str):
    print(recommendations)  # Print the error message
else:
    print(f"Recommended gifts for {recipient}:")
    for gift in recommendations:
        print(gift)

recipient = "David"
recommendations = recommend_gifts(recipient)

if isinstance(recommendations, str):
    print(recommendations)  # Print the error message
else:
    print(f"Recommended gifts for {recipient}:")
    for gift in recommendations:
        print(gift)
```

Key improvements and explanations:

* **Dummy Data:**  Uses `recipient_profiles` and `gift_catalog` to simulate data you would get from social media analysis and a product database.  Crucially, the data is structured in a way that allows the recommendation engine to work.
* **`recommend_gifts` function:** This is the core function.  It takes a recipient's name as input and returns a list of recommended gifts.
* **Profile Lookup:**  Checks if the recipient exists in the database (a dictionary of recipient profiles).
* **Relevance Scoring:**  This is the heart of the recommendation logic.  It iterates through the `gift_catalog` and calculates a `relevance_score` for each gift based on how well the gift's `tags` match the recipient's `interests`, `posts`, and `likes`.  Different sources (interests, posts, likes) are given different weights, which reflects the different levels of certainty of these sources of information.
* **String Matching:** Uses simple `in` operator for string matching, converting posts and likes to lowercase for case-insensitive matching.
* **Sorting:** Sorts the recommendations by relevance score using `recommendations.sort(key=lambda x: x[1], reverse=True)`. `key=lambda x: x[1]` tells `sort` to sort based on the *second* element of each tuple in the list (which is the score). `reverse=True` sorts in descending order.
* **Error Handling:**  Includes a check for recipients not found in the database and returns an error message. This prevents the program from crashing if it receives an unknown recipient. The if-else block surrounding the `print` statements also ensures the correct information is printed based on whether the function returns an error message or a list of recommendations.
* **Clearer Output:** Formats the output to include the relevance score for each gift, making it easier to understand the recommendations.
* **Comments:** Added detailed comments to explain each step of the code.
* **Modularity:**  The code is structured into functions to make it more reusable and easier to understand.

How to extend this example:

* **Social Media API Integration:**  Replace the dummy data with actual data retrieved from social media APIs (e.g., Twitter API, Facebook API, Instagram API).  You'll need to handle authentication, rate limiting, and data parsing.
* **Natural Language Processing (NLP):**  Use NLP techniques to extract more meaningful information from the recipient's posts and likes.  This could involve:
    * **Keyword Extraction:**  Identifying the most important keywords in the text.
    * **Sentiment Analysis:**  Determining the sentiment (positive, negative, neutral) expressed in the text.  This can help you avoid recommending gifts that are inconsistent with the recipient's views.
    * **Topic Modeling:**  Identifying the main topics discussed in the recipient's posts.
* **Machine Learning (ML):**
    * **Collaborative Filtering:**  Recommend gifts based on what other users with similar interests have liked.
    * **Content-Based Filtering:**  Recommend gifts based on the features of the gifts themselves (e.g., tags, description, price).
    * **Hybrid Approaches:**  Combine collaborative filtering and content-based filtering to get the best of both worlds.
* **Larger Gift Catalog:**  Expand the `gift_catalog` to include a wider variety of gifts.
* **Database:** Store the recipient profiles and gift catalog in a database (e.g., SQLite, PostgreSQL, MongoDB) for persistent storage and efficient retrieval.
* **User Interface:** Create a user interface (e.g., web app, mobile app) to allow users to easily search for gifts.

This example provides a basic framework for building a personalized gift recommendation system.  By incorporating the suggestions above, you can create a more sophisticated and accurate system.  Remember that working with real social media data requires careful attention to privacy and ethical considerations.  Always respect user data and comply with the terms of service of the social media platforms you are using.