Skip to content

Exa

ExaToolSpec #

Bases: BaseToolSpec

工具规范。

Source code in llama_index/tools/exa/base.py 
 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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
class ExaToolSpec(BaseToolSpec):
    """工具规范。"""

    spec_functions = [
        "search",
        "retrieve_documents",
        "search_and_retrieve_documents",
        "search_and_retrieve_highlights",
        "find_similar",
        "current_date",
    ]

    def __init__(
        self,
        api_key: str,
        verbose: bool = True,
        max_characters: int = 2000,
    ) -> None:
        """使用参数进行初始化。"""
        from exa_py import Exa

        self.client = Exa(api_key=api_key, user_agent="llama-index")
        self._verbose = verbose
        # max characters for the text field in the search_and_contents function
        self._max_characters = max_characters

    def search(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List:
        """Exa允许您使用自然语言查询来搜索互联网。

Args:
    query（str）：作为链接提供内容答案的自然语言查询，例如：“这是关于太空的最新新闻：”
    num_results（可选[int]）：要返回的结果数量。默认为10。
    include_domains（可选[List(str)]）：限制搜索到特定站点的顶级域名列表，如["wsj.com"]。
    exclude_domains（可选[List(str)]）：要排除的顶级域名。
    start_published_date（可选[str]）：日期字符串，如“2020-06-15”。从`current_date`获取日期。
    end_published_date（可选[str]）：结束日期字符串。
"""
        response = self.client.search(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [
            {"title": result.title, "url": result.url, "id": result.id}
            for result in response.results
        ]

    def retrieve_documents(self, ids: List[str]) -> List[Document]:
        """检索由`exa_search`返回的文档文本列表，使用ID字段。

Args:
    ids（List(str)）：要检索的文档的ID。
"""
        response = self.client.get_contents(ids)
        return [Document(text=result.text) for result in response.results]

    def find_similar(
        self,
        url: str,
        num_results: Optional[int] = 3,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List:
        """获取与给定网址相似的文档列表。

Args:
    url (str): 要查找相似结果的网页
    num_results (Optional[int]): 要返回的结果数量。默认为3。
    start_published_date (Optional[str]): 一个日期字符串，如"2020-06-15"
    end_published_date (Optional[str]): 结束日期字符串
"""
        response = self.client.find_similar(
            url,
            num_results=num_results,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
        )
        return [
            {"title": result.title, "url": result.url, "id": result.id}
            for result in response.results
        ]

    def search_and_retrieve_documents(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List[Document]:
        """将`search`和`retrieve_documents`的功能结合起来。

Args:
    query (str): 自然语言查询
    num_results (Optional[int]): 结果数量，默认为10。
    include_domains (Optional[List(str)]): 要搜索的顶级域名列表，如["wsj.com"]
    exclude_domains (Optional[List(str)]): 要排除的顶级域名。
    start_published_date (Optional[str]): 日期字符串，如"2020-06-15"。
    end_published_date (Optional[str]): 结束日期字符串。
"""
        response = self.client.search_and_contents(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
            text={"max_characters": self._max_characters},
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [Document(text=document.text) for document in response.results]

    def search_and_retrieve_highlights(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List[Document]:
        """搜索并检索文档中的摘要（智能摘录）。

Args:
    query（str）：自然语言查询
    num_results（Optional[int]）：结果数量。默认为10。
    include_domains（Optional[List(str)]）：要搜索的顶级域名列表，如["wsj.com"]
    exclude_domains（Optional[List(str)]）：要排除的顶级域名。
    start_published_date（Optional[str]）：日期字符串，如"2020-06-15"。
    end_published_date（Optional[str]）：结束日期字符串
"""
        response = self.client.search_and_contents(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
            highlights=True,
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [Document(text=document.highlights[0]) for document in response.results]

    def current_date(self):
        """一个返回今天日期的函数。

在调用任何需要时间戳作为参数的其他函数之前，请先调用此函数。
"""
        return datetime.date.today()

search #

search(
    query: str,
    num_results: Optional[int] = 10,
    include_domains: Optional[List[str]] = None,
    exclude_domains: Optional[List[str]] = None,
    start_published_date: Optional[str] = None,
    end_published_date: Optional[str] = None,
) -> List

Exa允许您使用自然语言查询来搜索互联网。

Source code in llama_index/tools/exa/base.py 
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
    def search(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List:
        """Exa允许您使用自然语言查询来搜索互联网。

Args:
    query（str）：作为链接提供内容答案的自然语言查询，例如：“这是关于太空的最新新闻：”
    num_results（可选[int]）：要返回的结果数量。默认为10。
    include_domains（可选[List(str)]）：限制搜索到特定站点的顶级域名列表，如["wsj.com"]。
    exclude_domains（可选[List(str)]）：要排除的顶级域名。
    start_published_date（可选[str]）：日期字符串，如“2020-06-15”。从`current_date`获取日期。
    end_published_date（可选[str]）：结束日期字符串。
"""
        response = self.client.search(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [
            {"title": result.title, "url": result.url, "id": result.id}
            for result in response.results
        ]

retrieve_documents #

retrieve_documents(ids: List[str]) -> List[Document]

检索由exa_search返回的文档文本列表，使用ID字段。

Source code in llama_index/tools/exa/base.py 
71
72
73
74
75
76
77
78
    def retrieve_documents(self, ids: List[str]) -> List[Document]:
        """检索由`exa_search`返回的文档文本列表，使用ID字段。

Args:
    ids（List(str)）：要检索的文档的ID。
"""
        response = self.client.get_contents(ids)
        return [Document(text=result.text) for result in response.results]

find_similar #

find_similar(
    url: str,
    num_results: Optional[int] = 3,
    start_published_date: Optional[str] = None,
    end_published_date: Optional[str] = None,
) -> List

获取与给定网址相似的文档列表。

Parameters:

Name Type Description Default
url str

要查找相似结果的网页

 required
num_results Optional[int]

要返回的结果数量。默认为3。

 3
start_published_date Optional[str]

一个日期字符串，如"2020-06-15"

 None
end_published_date Optional[str]

结束日期字符串

 None
Source code in llama_index/tools/exa/base.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
    def find_similar(
        self,
        url: str,
        num_results: Optional[int] = 3,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List:
        """获取与给定网址相似的文档列表。

Args:
    url (str): 要查找相似结果的网页
    num_results (Optional[int]): 要返回的结果数量。默认为3。
    start_published_date (Optional[str]): 一个日期字符串，如"2020-06-15"
    end_published_date (Optional[str]): 结束日期字符串
"""
        response = self.client.find_similar(
            url,
            num_results=num_results,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
        )
        return [
            {"title": result.title, "url": result.url, "id": result.id}
            for result in response.results
        ]

search_and_retrieve_documents #

search_and_retrieve_documents(
    query: str,
    num_results: Optional[int] = 10,
    include_domains: Optional[List[str]] = None,
    exclude_domains: Optional[List[str]] = None,
    start_published_date: Optional[str] = None,
    end_published_date: Optional[str] = None,
) -> List[Document]

将search和retrieve_documents的功能结合起来。

Parameters:

Name Type Description Default
query str

自然语言查询

 required
num_results Optional[int]

结果数量，默认为10。

 10
include_domains Optional[List(str)]

要搜索的顶级域名列表，如["wsj.com"]

 None
exclude_domains Optional[List(str)]

要排除的顶级域名。

 None
start_published_date Optional[str]

日期字符串，如"2020-06-15"。

 None
end_published_date Optional[str]

结束日期字符串。

 None
Source code in llama_index/tools/exa/base.py 
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
137
    def search_and_retrieve_documents(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List[Document]:
        """将`search`和`retrieve_documents`的功能结合起来。

Args:
    query (str): 自然语言查询
    num_results (Optional[int]): 结果数量，默认为10。
    include_domains (Optional[List(str)]): 要搜索的顶级域名列表，如["wsj.com"]
    exclude_domains (Optional[List(str)]): 要排除的顶级域名。
    start_published_date (Optional[str]): 日期字符串，如"2020-06-15"。
    end_published_date (Optional[str]): 结束日期字符串。
"""
        response = self.client.search_and_contents(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
            text={"max_characters": self._max_characters},
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [Document(text=document.text) for document in response.results]

search_and_retrieve_highlights #

search_and_retrieve_highlights(
    query: str,
    num_results: Optional[int] = 10,
    include_domains: Optional[List[str]] = None,
    exclude_domains: Optional[List[str]] = None,
    start_published_date: Optional[str] = None,
    end_published_date: Optional[str] = None,
) -> List[Document]

搜索并检索文档中的摘要（智能摘录）。

Source code in llama_index/tools/exa/base.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
    def search_and_retrieve_highlights(
        self,
        query: str,
        num_results: Optional[int] = 10,
        include_domains: Optional[List[str]] = None,
        exclude_domains: Optional[List[str]] = None,
        start_published_date: Optional[str] = None,
        end_published_date: Optional[str] = None,
    ) -> List[Document]:
        """搜索并检索文档中的摘要（智能摘录）。

Args:
    query（str）：自然语言查询
    num_results（Optional[int]）：结果数量。默认为10。
    include_domains（Optional[List(str)]）：要搜索的顶级域名列表，如["wsj.com"]
    exclude_domains（Optional[List(str)]）：要排除的顶级域名。
    start_published_date（Optional[str]）：日期字符串，如"2020-06-15"。
    end_published_date（Optional[str]）：结束日期字符串
"""
        response = self.client.search_and_contents(
            query,
            num_results=num_results,
            include_domains=include_domains,
            exclude_domains=exclude_domains,
            start_published_date=start_published_date,
            end_published_date=end_published_date,
            use_autoprompt=True,
            highlights=True,
        )
        if self._verbose:
            print(f"[Exa Tool] Autoprompt: {response.autoprompt_string}")
        return [Document(text=document.highlights[0]) for document in response.results]

current_date #

current_date()

一个返回今天日期的函数。

在调用任何需要时间戳作为参数的其他函数之前，请先调用此函数。

Source code in llama_index/tools/exa/base.py 
172
173
174
175
176
177
    def current_date(self):
        """一个返回今天日期的函数。

在调用任何需要时间戳作为参数的其他函数之前，请先调用此函数。
"""
        return datetime.date.today()