Joachim M. Vis commited on
Commit
cd85360
·
verified ·
1 Parent(s): 102702a

Update README.md

Browse files
Files changed (1) hide show
  1. README.md +306 -304
README.md CHANGED
@@ -1,305 +1,307 @@
1
- ---
2
- title: GAIA Agent
3
- emoji: 🤖
4
- colorFrom: blue
5
- colorTo: green
6
- sdk: gradio
7
- sdk_version: 5.25.2
8
- app_file: app.py
9
- pinned: false
10
- ---
11
-
12
- # GAIA Agent - Hugging Face Agents Course Final Project
13
-
14
- ## Project Overview
15
-
16
- This project implements an intelligent agent capable of answering questions from the GAIA (Grounded AI Alignment) benchmark as part of the Hugging Face Agents Course final assignment. The agent leverages LangChain/LangGraph frameworks and various tools to solve complex, multi-step reasoning tasks.
17
-
18
- ## What is GAIA?
19
-
20
- GAIA is a benchmark designed to evaluate AI assistants on real-world tasks that require a combination of core capabilities:
21
- - Reasoning across multiple steps
22
- - Multimodal understanding (text, images, etc.)
23
- - Web browsing and information retrieval
24
- - Proficient tool use
25
-
26
- The benchmark consists of 466 carefully curated questions that are conceptually simple for humans (~92% success rate) but challenging for current AI systems (GPT-4 with plugins: ~15% success rate).
27
-
28
- ## Challenge Requirements
29
-
30
- - **Task**: Create an agent that answers questions from a subset of GAIA (20 questions from level 1)
31
- - **Success Criteria**: Score at least 30% on the benchmark
32
- - **Evaluation Method**: Exact match comparison with ground truth answers
33
- - **Response Format**: Answers should be concise (number, few words, or comma-separated list)
34
-
35
- ## Technical Architecture
36
-
37
- Our implementation uses:
38
-
39
- 1. **LangChain/LangGraph**: For creating a flexible, modular agent architecture
40
- 2. **Supabase**: For memory management and persistence
41
- 3. **Web Tools**: Integration with search engines (DuckDuckGo, Serper), academic resources (arXiv), and AI assistants (Perplexity)
42
- 4. **Gradio**: For the user interface and submission process
43
-
44
- ## Project Structure
45
-
46
- ```
47
- ├── README.md # Project documentation
48
- ├── app.py # Main application file with Gradio interface
49
- ├── requirements.txt # Project dependencies
50
- ├── agent/ # Agent implementation
51
- │ ├── __init__.py # Package initialization
52
- │ ├── agent.py # Main agent class
53
- │ ├── config.py # Configuration settings
54
- │ ├── graph.py # LangGraph workflow definition
55
- │ └── tool_registry.py # Tool registration and management
56
- ├── tools/ # Tool implementations
57
- │ ├── __init__.py # Package initialization
58
- │ ├── web_tools.py # Web browsing and search tools
59
- │ ├── reasoning_tools.py # Reasoning and analysis tools
60
- │ ├── multimodal_tools.py # Tools for handling images and other media
61
- │ ├── arxiv_tool.py # Tools for searching academic papers
62
- │ └── perplexity_tool.py # Integration with Perplexity AI
63
- ├── memory/ # Memory management
64
- │ ├── __init__.py # Package initialization
65
- │ ├── supabase_memory.py # Supabase integration for memory
66
- │ ├── supabase_memory_patch.py # Patches for Supabase memory
67
- │ └── simplified_memory_fix.py # Simplified memory implementation
68
- └── utils/ # Utility functions
69
- ├── __init__.py # Package initialization
70
- ├── parsing.py # Functions for parsing questions and answers
71
- └── formatting.py # Formatting utilities
72
- ```
73
-
74
- ## Implementation Approach
75
-
76
- Our agent follows a multi-step process to answer GAIA questions:
77
-
78
- 1. **Question Analysis**: Parse and understand the question, identifying required tools and information sources
79
- 2. **Planning**: Develop a step-by-step plan to answer the question
80
- 3. **Tool Execution**: Use appropriate tools in the correct sequence
81
- 4. **Answer Formulation**: Extract and format the precise answer from the results
82
- 5. **Verification**: Validate the answer format and content before submission
83
-
84
- ## Key Features
85
-
86
- - **Modular Architecture**: Easily extensible with new tools and capabilities
87
- - **Robust Error Handling**: Graceful recovery from tool failures or unexpected results
88
- - **Efficient Tool Selection**: Smart selection of the most appropriate tools for each question
89
- - **Answer Precision**: Focus on extracting exact answers that match the ground truth format
90
- - **Memory Integration**: Persistent memory across sessions using Supabase
91
-
92
- ## Getting Started
93
-
94
- ### Prerequisites
95
-
96
- - Python 3.8 or higher
97
- - OpenAI API key
98
- - Supabase account and API key (for memory features)
99
- - Optional: Serper API key (for enhanced search)
100
- - Optional: Perplexity API key (for enhanced reasoning)
101
-
102
- ### Installation
103
-
104
- 1. Clone this repository
105
- 2. Install dependencies:
106
- ```bash
107
- pip install -r requirements.txt
108
- ```
109
-
110
- > **Note**: If you encounter issues with the `langchain_openai` dependency, make sure you have the latest version installed:
111
- > ```bash
112
- > pip install --upgrade langchain_openai
113
- > ```
114
-
115
- 3. Set up environment variables (create a `.env` file in the project root):
116
- ```
117
- OPENAI_API_KEY=your_openai_api_key
118
- SUPABASE_KEY=your_supabase_api_key
119
- SERPER_API_KEY=your_serper_api_key (optional)
120
- PERPLEXITY_API_KEY=your_perplexity_api_key (optional)
121
- ```
122
-
123
- 4. Run the application:
124
- ```bash
125
- python app.py
126
- ```
127
-
128
- 5. Log in with your Hugging Face account
129
- 6. Click "Run Evaluation & Submit All Answers" to test the agent
130
-
131
- ## Testing
132
-
133
- The project includes comprehensive unit tests for all components:
134
-
135
- - **Agent Tests**: Test the GAIAAgent class and its workflow
136
- - **Tools Tests**: Test the web, reasoning, and multimodal tools
137
- - **Memory Tests**: Test the memory components and Supabase integration
138
- - **Utils Tests**: Test utility functions for parsing and formatting
139
- - **Integration Tests**: Test integration with external APIs like OpenAI and Perplexity
140
-
141
- To run all tests:
142
- ```bash
143
- python -m unittest discover tests
144
- ```
145
-
146
- To run specific test files:
147
- ```bash
148
- python -m unittest tests.test_agent
149
- python -m unittest tests.test_tools
150
- python -m unittest tests.test_memory
151
- python -m unittest tests.test_utils
152
- ```
153
-
154
- ### OpenAI Integration Testing
155
-
156
- The project includes specialized tests for OpenAI integration with newer models:
157
-
158
- ```bash
159
- # Test OpenAI integration with newer models
160
- python tests/test_openai_integration.py
161
-
162
- # Test OpenAI integration with GAIA agent
163
- python tests/test_openai_integration.py --test-agent
164
-
165
- # Test GAIA agent with multiple AI providers (OpenAI and Perplexity)
166
- python tests/test_gaia_multi_provider.py
167
- ```
168
-
169
- For convenience, you can run all OpenAI integration tests at once:
170
-
171
- ```bash
172
- # Run all OpenAI integration tests
173
- python tests/run_openai_tests.py
174
-
175
- # Run all tests with verbose logging
176
- python tests/run_openai_tests.py --verbose
177
-
178
- # Run all tests and save results to a custom directory
179
- python tests/run_openai_tests.py --output my_test_results
180
-
181
- # Stop running tests after the first failure
182
- python tests/run_openai_tests.py --stop-on-failure
183
- ```
184
-
185
- These tests verify that:
186
- - The OpenAI API connection works correctly
187
- - Newer models like GPT-4o can be used successfully
188
- - The GAIA agent can use both OpenAI and Perplexity tools together
189
-
190
- ### API Integration Testing
191
-
192
- To test all API integrations together:
193
-
194
- ```bash
195
- # Run all API integration tests
196
- python tests/run_all_apis_integration_test.py
197
-
198
- # Run with verbose logging
199
- python tests/run_all_apis_integration_test.py --verbose
200
-
201
- # Specify a custom output file
202
- python tests/run_all_apis_integration_test.py --report-file my_report.json
203
- ```
204
-
205
- ### Supabase Integration Testing
206
-
207
- To test the Supabase memory integration:
208
-
209
- ```bash
210
- # Run all Supabase integration tests
211
- python tests/run_supabase_integration_tests.py
212
-
213
- # Run with verbose logging
214
- python tests/run_supabase_integration_tests.py --verbose
215
-
216
- # Specify a custom output directory
217
- python tests/run_supabase_integration_tests.py --output-dir custom_docs
218
- ```
219
-
220
- ## Evaluation
221
-
222
- The agent is evaluated on its ability to provide exact matches to the ground truth answers for the GAIA benchmark questions. The submission process includes:
223
-
224
- - Fetching questions from the course API
225
- - Running the agent on each question
226
- - Submitting answers for scoring
227
- - Viewing results on the leaderboard
228
-
229
- ## Benchmark Testing
230
-
231
- The project includes a benchmark testing framework to evaluate the agent's performance:
232
-
233
- ```bash
234
- # Run benchmark tests with default settings
235
- python -m tests.benchmark --output benchmark_results.json
236
-
237
- # Run benchmark tests with custom questions
238
- python -m tests.benchmark --questions custom_questions.json --output benchmark_results.json
239
-
240
- # Run benchmark tests with a specific number of questions
241
- python -m tests.benchmark --max-questions 5 --output benchmark_results.json
242
- ```
243
-
244
- The benchmark testing framework:
245
- - Tests the agent against sample questions
246
- - Measures performance metrics (accuracy, latency, resource usage)
247
- - Generates detailed reports of benchmark results
248
- - Allows comparison of different agent configurations
249
-
250
- ## Troubleshooting
251
-
252
- ### Common Issues
253
-
254
- #### 1. langchain_openai Dependency Issues
255
-
256
- If you encounter errors related to the `langchain_openai` package, such as:
257
- - `ImportError: No module named 'langchain_openai'`
258
- - `AttributeError: module 'langchain_openai' has no attribute 'ChatOpenAI'`
259
-
260
- Try the following solutions:
261
- - Ensure you have the latest version installed: `pip install --upgrade langchain_openai`
262
- - Make sure you're using the correct import: `from langchain_openai import ChatOpenAI`
263
- - Check for conflicts with older langchain versions: `pip uninstall langchain-openai` (note the hyphen)
264
-
265
- #### 2. API Connection Issues
266
-
267
- If you're having trouble connecting to external APIs:
268
- - Verify that your API keys are correctly set in the environment variables
269
- - Check that the API service is not experiencing downtime
270
- - Ensure you have a stable internet connection
271
- - Check for rate limiting or quota issues
272
-
273
- #### 3. Supabase Connection Issues
274
-
275
- If you're having trouble with Supabase:
276
- - Verify that your Supabase URL and API key are correctly set
277
- - Ensure that the required tables exist in your Supabase project
278
- - Check that your API key has the necessary permissions
279
- - Verify that your Supabase project is active
280
-
281
- #### 4. Memory Issues
282
-
283
- If you're experiencing issues with the agent's memory:
284
- - Check that memory is enabled in the configuration
285
- - Verify that the table names are correctly set
286
- - Ensure that the TTL and cache size settings are appropriate
287
- - Check for errors in the Supabase logs
288
-
289
- ## Documentation
290
-
291
- Comprehensive documentation is available in the `docs/` directory:
292
-
293
- - [Usage Examples](docs/examples.md): Examples of how to use the GAIA agent in different scenarios
294
- - [Configuration Guide](docs/configuration.md): Detailed information about configuration options
295
- - [Deployment Guide](docs/deployment.md): Instructions for deploying the agent in various environments
296
- - [OpenAI Integration Testing](docs/openai_integration_testing.md): Guide for testing OpenAI integration with newer models
297
- - [Connection Verification](docs/connection_verification.md): Guide for verifying connections to external services
298
- - [Supabase Memory Integration](docs/supabase_memory_integration.md): Guide for setting up and using Supabase memory
299
- - [All APIs Integration Testing](docs/all_apis_integration_testing.md): Guide for testing all API integrations together
300
- - [Multi-Search Integration](docs/multi_search_integration.md): Guide for using multiple search providers
301
- - [GAIA Memory Integration](docs/gaia_memory_integration.md): Guide for using memory in the GAIA agent
302
-
303
- ## License
304
-
 
 
305
  This project is part of the Hugging Face Agents Course and follows its licensing terms.
 
1
+ ---
2
+ title: GAIA Agent Assessment
3
+ emoji: 🤖
4
+ colorFrom: blue
5
+ colorTo: green
6
+ sdk: gradio
7
+ sdk_version: 3.50.2
8
+ app_file: app.py
9
+ pinned: false
10
+ license: mit
11
+ hf_oauth: true
12
+ ---
13
+
14
+ # GAIA Agent - Hugging Face Agents Course Final Project
15
+
16
+ ## Project Overview
17
+
18
+ This project implements an intelligent agent capable of answering questions from the GAIA (Grounded AI Alignment) benchmark as part of the Hugging Face Agents Course final assignment. The agent leverages LangChain/LangGraph frameworks and various tools to solve complex, multi-step reasoning tasks.
19
+
20
+ ## What is GAIA?
21
+
22
+ GAIA is a benchmark designed to evaluate AI assistants on real-world tasks that require a combination of core capabilities:
23
+ - Reasoning across multiple steps
24
+ - Multimodal understanding (text, images, etc.)
25
+ - Web browsing and information retrieval
26
+ - Proficient tool use
27
+
28
+ The benchmark consists of 466 carefully curated questions that are conceptually simple for humans (~92% success rate) but challenging for current AI systems (GPT-4 with plugins: ~15% success rate).
29
+
30
+ ## Challenge Requirements
31
+
32
+ - **Task**: Create an agent that answers questions from a subset of GAIA (20 questions from level 1)
33
+ - **Success Criteria**: Score at least 30% on the benchmark
34
+ - **Evaluation Method**: Exact match comparison with ground truth answers
35
+ - **Response Format**: Answers should be concise (number, few words, or comma-separated list)
36
+
37
+ ## Technical Architecture
38
+
39
+ Our implementation uses:
40
+
41
+ 1. **LangChain/LangGraph**: For creating a flexible, modular agent architecture
42
+ 2. **Supabase**: For memory management and persistence
43
+ 3. **Web Tools**: Integration with search engines (DuckDuckGo, Serper), academic resources (arXiv), and AI assistants (Perplexity)
44
+ 4. **Gradio**: For the user interface and submission process
45
+
46
+ ## Project Structure
47
+
48
+ ```
49
+ ├── README.md # Project documentation
50
+ ├── app.py # Main application file with Gradio interface
51
+ ├── requirements.txt # Project dependencies
52
+ ├── agent/ # Agent implementation
53
+ │ ├── __init__.py # Package initialization
54
+ │ ├── agent.py # Main agent class
55
+ │ ├── config.py # Configuration settings
56
+ │ ├── graph.py # LangGraph workflow definition
57
+ │ └── tool_registry.py # Tool registration and management
58
+ ├── tools/ # Tool implementations
59
+ │ ├── __init__.py # Package initialization
60
+ │ ├── web_tools.py # Web browsing and search tools
61
+ │ ├── reasoning_tools.py # Reasoning and analysis tools
62
+ │ ├── multimodal_tools.py # Tools for handling images and other media
63
+ │ ├── arxiv_tool.py # Tools for searching academic papers
64
+ │ └── perplexity_tool.py # Integration with Perplexity AI
65
+ ├── memory/ # Memory management
66
+ │ ├── __init__.py # Package initialization
67
+ │ ├── supabase_memory.py # Supabase integration for memory
68
+ │ ├── supabase_memory_patch.py # Patches for Supabase memory
69
+ │ └── simplified_memory_fix.py # Simplified memory implementation
70
+ └── utils/ # Utility functions
71
+ ├── __init__.py # Package initialization
72
+ ├── parsing.py # Functions for parsing questions and answers
73
+ └── formatting.py # Formatting utilities
74
+ ```
75
+
76
+ ## Implementation Approach
77
+
78
+ Our agent follows a multi-step process to answer GAIA questions:
79
+
80
+ 1. **Question Analysis**: Parse and understand the question, identifying required tools and information sources
81
+ 2. **Planning**: Develop a step-by-step plan to answer the question
82
+ 3. **Tool Execution**: Use appropriate tools in the correct sequence
83
+ 4. **Answer Formulation**: Extract and format the precise answer from the results
84
+ 5. **Verification**: Validate the answer format and content before submission
85
+
86
+ ## Key Features
87
+
88
+ - **Modular Architecture**: Easily extensible with new tools and capabilities
89
+ - **Robust Error Handling**: Graceful recovery from tool failures or unexpected results
90
+ - **Efficient Tool Selection**: Smart selection of the most appropriate tools for each question
91
+ - **Answer Precision**: Focus on extracting exact answers that match the ground truth format
92
+ - **Memory Integration**: Persistent memory across sessions using Supabase
93
+
94
+ ## Getting Started
95
+
96
+ ### Prerequisites
97
+
98
+ - Python 3.8 or higher
99
+ - OpenAI API key
100
+ - Supabase account and API key (for memory features)
101
+ - Optional: Serper API key (for enhanced search)
102
+ - Optional: Perplexity API key (for enhanced reasoning)
103
+
104
+ ### Installation
105
+
106
+ 1. Clone this repository
107
+ 2. Install dependencies:
108
+ ```bash
109
+ pip install -r requirements.txt
110
+ ```
111
+
112
+ > **Note**: If you encounter issues with the `langchain_openai` dependency, make sure you have the latest version installed:
113
+ > ```bash
114
+ > pip install --upgrade langchain_openai
115
+ > ```
116
+
117
+ 3. Set up environment variables (create a `.env` file in the project root):
118
+ ```
119
+ OPENAI_API_KEY=your_openai_api_key
120
+ SUPABASE_KEY=your_supabase_api_key
121
+ SERPER_API_KEY=your_serper_api_key (optional)
122
+ PERPLEXITY_API_KEY=your_perplexity_api_key (optional)
123
+ ```
124
+
125
+ 4. Run the application:
126
+ ```bash
127
+ python app.py
128
+ ```
129
+
130
+ 5. Log in with your Hugging Face account
131
+ 6. Click "Run Evaluation & Submit All Answers" to test the agent
132
+
133
+ ## Testing
134
+
135
+ The project includes comprehensive unit tests for all components:
136
+
137
+ - **Agent Tests**: Test the GAIAAgent class and its workflow
138
+ - **Tools Tests**: Test the web, reasoning, and multimodal tools
139
+ - **Memory Tests**: Test the memory components and Supabase integration
140
+ - **Utils Tests**: Test utility functions for parsing and formatting
141
+ - **Integration Tests**: Test integration with external APIs like OpenAI and Perplexity
142
+
143
+ To run all tests:
144
+ ```bash
145
+ python -m unittest discover tests
146
+ ```
147
+
148
+ To run specific test files:
149
+ ```bash
150
+ python -m unittest tests.test_agent
151
+ python -m unittest tests.test_tools
152
+ python -m unittest tests.test_memory
153
+ python -m unittest tests.test_utils
154
+ ```
155
+
156
+ ### OpenAI Integration Testing
157
+
158
+ The project includes specialized tests for OpenAI integration with newer models:
159
+
160
+ ```bash
161
+ # Test OpenAI integration with newer models
162
+ python tests/test_openai_integration.py
163
+
164
+ # Test OpenAI integration with GAIA agent
165
+ python tests/test_openai_integration.py --test-agent
166
+
167
+ # Test GAIA agent with multiple AI providers (OpenAI and Perplexity)
168
+ python tests/test_gaia_multi_provider.py
169
+ ```
170
+
171
+ For convenience, you can run all OpenAI integration tests at once:
172
+
173
+ ```bash
174
+ # Run all OpenAI integration tests
175
+ python tests/run_openai_tests.py
176
+
177
+ # Run all tests with verbose logging
178
+ python tests/run_openai_tests.py --verbose
179
+
180
+ # Run all tests and save results to a custom directory
181
+ python tests/run_openai_tests.py --output my_test_results
182
+
183
+ # Stop running tests after the first failure
184
+ python tests/run_openai_tests.py --stop-on-failure
185
+ ```
186
+
187
+ These tests verify that:
188
+ - The OpenAI API connection works correctly
189
+ - Newer models like GPT-4o can be used successfully
190
+ - The GAIA agent can use both OpenAI and Perplexity tools together
191
+
192
+ ### API Integration Testing
193
+
194
+ To test all API integrations together:
195
+
196
+ ```bash
197
+ # Run all API integration tests
198
+ python tests/run_all_apis_integration_test.py
199
+
200
+ # Run with verbose logging
201
+ python tests/run_all_apis_integration_test.py --verbose
202
+
203
+ # Specify a custom output file
204
+ python tests/run_all_apis_integration_test.py --report-file my_report.json
205
+ ```
206
+
207
+ ### Supabase Integration Testing
208
+
209
+ To test the Supabase memory integration:
210
+
211
+ ```bash
212
+ # Run all Supabase integration tests
213
+ python tests/run_supabase_integration_tests.py
214
+
215
+ # Run with verbose logging
216
+ python tests/run_supabase_integration_tests.py --verbose
217
+
218
+ # Specify a custom output directory
219
+ python tests/run_supabase_integration_tests.py --output-dir custom_docs
220
+ ```
221
+
222
+ ## Evaluation
223
+
224
+ The agent is evaluated on its ability to provide exact matches to the ground truth answers for the GAIA benchmark questions. The submission process includes:
225
+
226
+ - Fetching questions from the course API
227
+ - Running the agent on each question
228
+ - Submitting answers for scoring
229
+ - Viewing results on the leaderboard
230
+
231
+ ## Benchmark Testing
232
+
233
+ The project includes a benchmark testing framework to evaluate the agent's performance:
234
+
235
+ ```bash
236
+ # Run benchmark tests with default settings
237
+ python -m tests.benchmark --output benchmark_results.json
238
+
239
+ # Run benchmark tests with custom questions
240
+ python -m tests.benchmark --questions custom_questions.json --output benchmark_results.json
241
+
242
+ # Run benchmark tests with a specific number of questions
243
+ python -m tests.benchmark --max-questions 5 --output benchmark_results.json
244
+ ```
245
+
246
+ The benchmark testing framework:
247
+ - Tests the agent against sample questions
248
+ - Measures performance metrics (accuracy, latency, resource usage)
249
+ - Generates detailed reports of benchmark results
250
+ - Allows comparison of different agent configurations
251
+
252
+ ## Troubleshooting
253
+
254
+ ### Common Issues
255
+
256
+ #### 1. langchain_openai Dependency Issues
257
+
258
+ If you encounter errors related to the `langchain_openai` package, such as:
259
+ - `ImportError: No module named 'langchain_openai'`
260
+ - `AttributeError: module 'langchain_openai' has no attribute 'ChatOpenAI'`
261
+
262
+ Try the following solutions:
263
+ - Ensure you have the latest version installed: `pip install --upgrade langchain_openai`
264
+ - Make sure you're using the correct import: `from langchain_openai import ChatOpenAI`
265
+ - Check for conflicts with older langchain versions: `pip uninstall langchain-openai` (note the hyphen)
266
+
267
+ #### 2. API Connection Issues
268
+
269
+ If you're having trouble connecting to external APIs:
270
+ - Verify that your API keys are correctly set in the environment variables
271
+ - Check that the API service is not experiencing downtime
272
+ - Ensure you have a stable internet connection
273
+ - Check for rate limiting or quota issues
274
+
275
+ #### 3. Supabase Connection Issues
276
+
277
+ If you're having trouble with Supabase:
278
+ - Verify that your Supabase URL and API key are correctly set
279
+ - Ensure that the required tables exist in your Supabase project
280
+ - Check that your API key has the necessary permissions
281
+ - Verify that your Supabase project is active
282
+
283
+ #### 4. Memory Issues
284
+
285
+ If you're experiencing issues with the agent's memory:
286
+ - Check that memory is enabled in the configuration
287
+ - Verify that the table names are correctly set
288
+ - Ensure that the TTL and cache size settings are appropriate
289
+ - Check for errors in the Supabase logs
290
+
291
+ ## Documentation
292
+
293
+ Comprehensive documentation is available in the `docs/` directory:
294
+
295
+ - [Usage Examples](docs/examples.md): Examples of how to use the GAIA agent in different scenarios
296
+ - [Configuration Guide](docs/configuration.md): Detailed information about configuration options
297
+ - [Deployment Guide](docs/deployment.md): Instructions for deploying the agent in various environments
298
+ - [OpenAI Integration Testing](docs/openai_integration_testing.md): Guide for testing OpenAI integration with newer models
299
+ - [Connection Verification](docs/connection_verification.md): Guide for verifying connections to external services
300
+ - [Supabase Memory Integration](docs/supabase_memory_integration.md): Guide for setting up and using Supabase memory
301
+ - [All APIs Integration Testing](docs/all_apis_integration_testing.md): Guide for testing all API integrations together
302
+ - [Multi-Search Integration](docs/multi_search_integration.md): Guide for using multiple search providers
303
+ - [GAIA Memory Integration](docs/gaia_memory_integration.md): Guide for using memory in the GAIA agent
304
+
305
+ ## License
306
+
307
  This project is part of the Hugging Face Agents Course and follows its licensing terms.