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
class ProfilesMixin:
    def get_profile(self, identifier: Optional[str] = None) -> dict:
        """Return public profile info for a user.

        Example:
            ```python
            profile = client.get_profile("ludo")
            # or your own profile
            me = client.get_profile()
            ```

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

        Returns:
            Profile dict.
        """
        args: dict[str, Any] = {}
        if identifier:
            args["identifier"] = identifier
        return self._mcp_tool_call("get_profile", args)

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

        Example:
            ```python
            results = client.find_user_by_name("ludo")
            ```

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

        Returns:
            Dict with match results.
        """
        return self._mcp_tool_call("find_user_by_name", {"name": 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 per-name matches and resolved_user_ids map.
        """
        return self._mcp_tool_call(
            "find_users_by_names",
            {"names": names, "limit_per_name": 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.

        Unlike :meth:`perspective_search` (which returns answers), this returns
        *who* knows about the topic — useful for resolving experts before calling
        :meth:`ask`.

        Example:
            ```python
            result = client.find_users_on_topic("product-led growth")
            for expert in result["users"]:
                print(expert["username"], expert["score"])
            ```

        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 ``users`` list, each having ``username``, ``user_id``,
            and relevance info.
        """
        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_users_on_topic", 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["answer"])
            for view in result["viewpoints"]:
                print(view["username"], view["content"])
            ```

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

        Returns:
            Dict with synthesized answer and individual viewpoints.
        """
        return self._mcp_tool_call("perspective_search", {"question": question})

get_profile 

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

Return public profile info for a user.

Example 
profile = client.get_profile("ludo")
# or your own profile
me = client.get_profile()

Parameters:

Name Type Description Default
identifier Optional[str]

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

 None

Returns:

Type Description
dict

Profile dict.
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
def get_profile(self, identifier: Optional[str] = None) -> dict:
    """Return public profile info for a user.

    Example:
        ```python
        profile = client.get_profile("ludo")
        # or your own profile
        me = client.get_profile()
        ```

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

    Returns:
        Profile dict.
    """
    args: dict[str, Any] = {}
    if identifier:
        args["identifier"] = identifier
    return self._mcp_tool_call("get_profile", args)

find_user_by_name 

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

Search for SuperMe users by name.

Example 
results = client.find_user_by_name("ludo")

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 match results.
Source code in superme_sdk/services/_profiles.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def find_user_by_name(self, name: str, *, limit: int = 10) -> dict:
    """Search for SuperMe users by name.

    Example:
        ```python
        results = client.find_user_by_name("ludo")
        ```

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

    Returns:
        Dict with match results.
    """
    return self._mcp_tool_call("find_user_by_name", {"name": 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 per-name matches and resolved_user_ids map.
Source code in superme_sdk/services/_profiles.py 
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
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 per-name matches and resolved_user_ids map.
    """
    return self._mcp_tool_call(
        "find_users_by_names",
        {"names": names, "limit_per_name": 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.

Unlike :meth:perspective_search (which returns answers), this returns who knows about the topic — useful for resolving experts before calling :meth:ask.

Example 
result = client.find_users_on_topic("product-led growth")
for expert in result["users"]:
    print(expert["username"], expert["score"])

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 users list, each having username, user_id,
dict

and relevance info.
Source code in superme_sdk/services/_profiles.py 
 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
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.

    Unlike :meth:`perspective_search` (which returns answers), this returns
    *who* knows about the topic — useful for resolving experts before calling
    :meth:`ask`.

    Example:
        ```python
        result = client.find_users_on_topic("product-led growth")
        for expert in result["users"]:
            print(expert["username"], expert["score"])
        ```

    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 ``users`` list, each having ``username``, ``user_id``,
        and relevance info.
    """
    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_users_on_topic", 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["answer"])
for view in result["viewpoints"]:
    print(view["username"], view["content"])

Parameters:

Name Type Description Default
question str

A topic or question to get expert takes on.

 required

Returns:

Type Description
dict

Dict with synthesized answer and individual viewpoints.
Source code in superme_sdk/services/_profiles.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
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["answer"])
        for view in result["viewpoints"]:
            print(view["username"], view["content"])
        ```

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

    Returns:
        Dict with synthesized answer and individual viewpoints.
    """
    return self._mcp_tool_call("perspective_search", {"question": question})