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
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``, ``connected_accounts``,
            ``connected_blogs``.
            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:
            return self._mcp_tool_call("get_my_profile", {})
        result = self._mcp_tool_call("find_profiles", {"identifier": identifier})
        users = result.get("users", []) if isinstance(result, dict) else []
        return users[0] if users 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(
            "find_profiles", {"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(
            "find_profiles",
            {"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("find_experts", args)

    def perspective_search(self, question: str) -> dict:
        """Get perspectives from multiple experts on a topic.

        Example:
            ```python
            result = client.perspective_search("What is product-market fit?")
            print(result["synthesis"])
            for p in result["perspectives"]:
                print(p["expert_name"], p["perspective"])
            ```

        Args:
            question: A topic or question to get expert takes on.

        Returns:
            Dict with ``perspectives`` list and ``synthesis`` string.
        """
        return self._mcp_tool_call("search_perspective", {"question": question})

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,
dict

title, location, avatar_image, connected_accounts,
dict

connected_blogs.
dict

When called with identifier: flat profile dict with user_id,
dict

in_network, name, and other public fields.
dict

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
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``, ``connected_accounts``,
        ``connected_blogs``.
        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:
        return self._mcp_tool_call("get_my_profile", {})
    result = self._mcp_tool_call("find_profiles", {"identifier": identifier})
    users = result.get("users", []) if isinstance(result, dict) else []
    return users[0] if users 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 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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(
        "find_profiles", {"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 
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
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(
        "find_profiles",
        {"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,
dict

user_name, why_selected, and relevance_score.
Source code in superme_sdk/services/_profiles.py 
 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
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("find_experts", args)

perspective_search(question: str) -> dict

Get perspectives from multiple experts on a topic.

Example 
result = client.perspective_search("What is product-market fit?")
print(result["synthesis"])
for p in result["perspectives"]:
    print(p["expert_name"], p["perspective"])

Parameters:

Name Type Description Default
question str

A topic or question to get expert takes on.

 required

Returns:

Type Description
dict

Dict with perspectives list and synthesis string.
Source code in superme_sdk/services/_profiles.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
def perspective_search(self, question: str) -> dict:
    """Get perspectives from multiple experts on a topic.

    Example:
        ```python
        result = client.perspective_search("What is product-market fit?")
        print(result["synthesis"])
        for p in result["perspectives"]:
            print(p["expert_name"], p["perspective"])
        ```

    Args:
        question: A topic or question to get expert takes on.

    Returns:
        Dict with ``perspectives`` list and ``synthesis`` string.
    """
    return self._mcp_tool_call("search_perspective", {"question": question})