Skip to content

Profiles

Source code in superme_sdk/services/_profiles.py 
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
class ProfilesMixin:
    def get_profile(self, identifier: Optional[str] = None) -> dict:
        """Return public profile info for a user.

        Example:
            ```python
            me = client.get_profile()
            profile = client.get_profile("ludo")
            print(profile["name"], profile["user_id"])
            ```

        Args:
            identifier: User ID, username, or full name. Omit for your own
                profile.

        Returns:
            When called without ``identifier`` (own profile): dict with
            ``name``, ``title``, ``location``, ``avatar_image``, and joined
            communities. When called with ``identifier``: flat profile dict with
            ``user_id``, ``in_network``, ``name``, and other public fields.
            Returns ``{}`` if no match is found.
        """
        if not identifier:
            result = self._mcp_read_resource("superme://me/profile")
            return result if isinstance(result, dict) else {}
        result = self._mcp_tool_call("user_profile_search", {"identifier": identifier})
        users = result.get("users", []) if isinstance(result, dict) else []
        return users[0] if users else {}

    def get_user_details(self, identifier: str) -> dict:
        """Read one user's full public profile by user_id or username.

        Unlike :meth:`get_profile` (a search card — name, title, location), this
        returns the deep profile: un-truncated summary plus structured work
        experience, education, and skills. Resolve a name to a user_id or
        username with :meth:`find_user_by_name` first.

        Example:
            ```python
            details = client.get_user_details("elena-verna")
            print(details["summary"])
            for job in details["work_experience"]:
                print(job["company"], job["title"])
            ```

        Args:
            identifier: A user_id or username (from a search result).

        Returns:
            Profile dict with ``user_id``, ``name``, ``title``, ``company``,
            ``summary``, ``skills``, ``work_experience``, and ``education``.
            Contains an ``error`` key if the profile is missing or not visible.
        """
        result = self._mcp_tool_call("user_details_read", {"identifier": identifier})
        return result if isinstance(result, dict) else {}

    def find_user_by_name(self, name: str, *, limit: int = 10) -> dict:
        """Search for SuperMe users by name.

        Example:
            ```python
            result = client.find_user_by_name("ludo")
            for u in result["users"]:
                print(u["user_id"], u["name"])
            ```

        Args:
            name: Full or partial name to search for.
            limit: Maximum results to return.

        Returns:
            Dict with ``users`` (list of matches) and ``workgroups`` keys.
        """
        return self._mcp_tool_call(
            "user_profile_search", {"identifier": name, "limit": limit}
        )

    def find_users_by_names(
        self, names: list[str], *, limit_per_name: int = 10
    ) -> dict:
        """Resolve multiple names to SuperMe users in a single call.

        Example:
            ```python
            result = client.find_users_by_names(["ludo", "duy"])
            ids = result["resolved_user_ids"]
            ```

        Args:
            names: List of names to look up.
            limit_per_name: Maximum matches per name.

        Returns:
            Dict with ``results``, ``resolved_user_ids``, and ``unresolved`` keys.
        """
        return self._mcp_tool_call(
            "user_profile_search",
            {"identifier": names, "limit": limit_per_name},
        )

    def find_users_on_topic(
        self,
        question: str,
        *,
        max_results: int = 10,
        excluded_user_ids: list[str] | None = None,
    ) -> dict:
        """Find SuperMe users who are experts on a topic.

        Example:
            ```python
            result = client.find_users_on_topic("product-led growth")
            for expert in result["experts"]:
                print(expert["user_name"], expert["why_selected"])
            ```

        Args:
            question: A topic or question to find experts on.
            max_results: Maximum number of experts to return (1-20, default 10).
            excluded_user_ids: User IDs to exclude from results.

        Returns:
            Dict with ``question`` and ``experts`` list, each having ``user_id``,
            ``user_name``, ``why_selected``, and ``relevance_score``.
        """
        args: dict[str, Any] = {"question": question, "max_results": max_results}
        if excluded_user_ids is not None:
            args["excluded_user_ids"] = excluded_user_ids
        return self._mcp_tool_call("user_expert_search", args)

get_profile 

get_profile(identifier: Optional[str] = None) -> dict

Return public profile info for a user.

Example 
me = client.get_profile()
profile = client.get_profile("ludo")
print(profile["name"], profile["user_id"])

Parameters:

Name Type Description Default
identifier Optional[str]

User ID, username, or full name. Omit for your own profile.

 None

Returns:

Type Description
dict

When called without identifier (own profile): dict with name, title, location, avatar_image, and joined communities. When called with identifier: flat profile dict with user_id, in_network, name, and other public fields. Returns {} if no match is found.
Source code in superme_sdk/services/_profiles.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def get_profile(self, identifier: Optional[str] = None) -> dict:
    """Return public profile info for a user.

    Example:
        ```python
        me = client.get_profile()
        profile = client.get_profile("ludo")
        print(profile["name"], profile["user_id"])
        ```

    Args:
        identifier: User ID, username, or full name. Omit for your own
            profile.

    Returns:
        When called without ``identifier`` (own profile): dict with
        ``name``, ``title``, ``location``, ``avatar_image``, and joined
        communities. When called with ``identifier``: flat profile dict with
        ``user_id``, ``in_network``, ``name``, and other public fields.
        Returns ``{}`` if no match is found.
    """
    if not identifier:
        result = self._mcp_read_resource("superme://me/profile")
        return result if isinstance(result, dict) else {}
    result = self._mcp_tool_call("user_profile_search", {"identifier": identifier})
    users = result.get("users", []) if isinstance(result, dict) else []
    return users[0] if users else {}

get_user_details 

get_user_details(identifier: str) -> dict

Read one user's full public profile by user_id or username.

Unlike :meth:get_profile (a search card — name, title, location), this returns the deep profile: un-truncated summary plus structured work experience, education, and skills. Resolve a name to a user_id or username with :meth:find_user_by_name first.

Example 
details = client.get_user_details("elena-verna")
print(details["summary"])
for job in details["work_experience"]:
    print(job["company"], job["title"])

Parameters:

Name Type Description Default
identifier str

A user_id or username (from a search result).

 required

Returns:

Type Description
dict

Profile dict with user_id, name, title, company, summary, skills, work_experience, and education. Contains an error key if the profile is missing or not visible.
Source code in superme_sdk/services/_profiles.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def get_user_details(self, identifier: str) -> dict:
    """Read one user's full public profile by user_id or username.

    Unlike :meth:`get_profile` (a search card — name, title, location), this
    returns the deep profile: un-truncated summary plus structured work
    experience, education, and skills. Resolve a name to a user_id or
    username with :meth:`find_user_by_name` first.

    Example:
        ```python
        details = client.get_user_details("elena-verna")
        print(details["summary"])
        for job in details["work_experience"]:
            print(job["company"], job["title"])
        ```

    Args:
        identifier: A user_id or username (from a search result).

    Returns:
        Profile dict with ``user_id``, ``name``, ``title``, ``company``,
        ``summary``, ``skills``, ``work_experience``, and ``education``.
        Contains an ``error`` key if the profile is missing or not visible.
    """
    result = self._mcp_tool_call("user_details_read", {"identifier": identifier})
    return result if isinstance(result, dict) else {}

find_user_by_name 

find_user_by_name(name: str, *, limit: int = 10) -> dict

Search for SuperMe users by name.

Example 
result = client.find_user_by_name("ludo")
for u in result["users"]:
    print(u["user_id"], u["name"])

Parameters:

Name Type Description Default
name str

Full or partial name to search for.

 required
limit int

Maximum results to return.

 10

Returns:

Type Description
dict

Dict with users (list of matches) and workgroups keys.
Source code in superme_sdk/services/_profiles.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def find_user_by_name(self, name: str, *, limit: int = 10) -> dict:
    """Search for SuperMe users by name.

    Example:
        ```python
        result = client.find_user_by_name("ludo")
        for u in result["users"]:
            print(u["user_id"], u["name"])
        ```

    Args:
        name: Full or partial name to search for.
        limit: Maximum results to return.

    Returns:
        Dict with ``users`` (list of matches) and ``workgroups`` keys.
    """
    return self._mcp_tool_call(
        "user_profile_search", {"identifier": name, "limit": limit}
    )

find_users_by_names 

find_users_by_names(
    names: list[str], *, limit_per_name: int = 10
) -> dict

Resolve multiple names to SuperMe users in a single call.

Example 
result = client.find_users_by_names(["ludo", "duy"])
ids = result["resolved_user_ids"]

Parameters:

Name Type Description Default
names list[str]

List of names to look up.

 required
limit_per_name int

Maximum matches per name.

 10

Returns:

Type Description
dict

Dict with results, resolved_user_ids, and unresolved keys.
Source code in superme_sdk/services/_profiles.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def find_users_by_names(
    self, names: list[str], *, limit_per_name: int = 10
) -> dict:
    """Resolve multiple names to SuperMe users in a single call.

    Example:
        ```python
        result = client.find_users_by_names(["ludo", "duy"])
        ids = result["resolved_user_ids"]
        ```

    Args:
        names: List of names to look up.
        limit_per_name: Maximum matches per name.

    Returns:
        Dict with ``results``, ``resolved_user_ids``, and ``unresolved`` keys.
    """
    return self._mcp_tool_call(
        "user_profile_search",
        {"identifier": names, "limit": limit_per_name},
    )

find_users_on_topic 

find_users_on_topic(
    question: str,
    *,
    max_results: int = 10,
    excluded_user_ids: list[str] | None = None,
) -> dict

Find SuperMe users who are experts on a topic.

Example 
result = client.find_users_on_topic("product-led growth")
for expert in result["experts"]:
    print(expert["user_name"], expert["why_selected"])

Parameters:

Name Type Description Default
question str

A topic or question to find experts on.

 required
max_results int

Maximum number of experts to return (1-20, default 10).

 10
excluded_user_ids list[str] | None

User IDs to exclude from results.

 None

Returns:

Type Description
dict

Dict with question and experts list, each having user_id, user_name, why_selected, and relevance_score.
Source code in superme_sdk/services/_profiles.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def find_users_on_topic(
    self,
    question: str,
    *,
    max_results: int = 10,
    excluded_user_ids: list[str] | None = None,
) -> dict:
    """Find SuperMe users who are experts on a topic.

    Example:
        ```python
        result = client.find_users_on_topic("product-led growth")
        for expert in result["experts"]:
            print(expert["user_name"], expert["why_selected"])
        ```

    Args:
        question: A topic or question to find experts on.
        max_results: Maximum number of experts to return (1-20, default 10).
        excluded_user_ids: User IDs to exclude from results.

    Returns:
        Dict with ``question`` and ``experts`` list, each having ``user_id``,
        ``user_name``, ``why_selected``, and ``relevance_score``.
    """
    args: dict[str, Any] = {"question": question, "max_results": max_results}
    if excluded_user_ids is not None:
        args["excluded_user_ids"] = excluded_user_ids
    return self._mcp_tool_call("user_expert_search", args)