Codex cli, Gemini cli, Claude code
AI Pair Programmer in Terminal
15 min readAug 10, 2025
Deploy codex-mini at Azure AI foundry created at East US 2.
In ~/.codex/config.toml
base_url = "https://<Azure AI foundry resource name>.openai.azure.com/openai"Result
user
write a python script to create an Azure AI Agent with file search capabilities
codex
Below is a standalone Python script that spins up an Azure AI Agent with file-se
arch capabilities. Just set the three environment variables (`PROJECT_ENDPOINT`,
`MODEL_DEPLOYMENT_NAME`, and `VECTOR_STORE_ID`) before running.
```python
#!/usr/bin/env python3
import os
from azure.ai.projects import AIProjectClient, FileSearchTool
from azure.identity import DefaultAzureCredential
def main():
# Ensure these environment variables are set:
# - PROJECT_ENDPOINT (e.g. https://your-resource.openai.azure.com)
# - MODEL_DEPLOYMENT_NAME (your Azure OpenAI deployment)
# - VECTOR_STORE_ID (your vector store resource ID)
endpoint = os.environ["PROJECT_ENDPOINT"]
model_deployment = os.environ["MODEL_DEPLOYMENT_NAME"]
vector_store_id = os.environ["VECTOR_STORE_ID"]
# 1. Configure the file-search tool to point at your vector store
file_search_tool = FileSearchTool(vector_store_ids=[vector_store_id])
# 2. Initialize the AIProjectClient using DefaultAzureCredential
project_client = AIProjectClient(
endpoint=endpoint,
credential=DefaultAzureCredential(),
)
# 3. Create the agent with file-search enabled
with project_client:
agents_client = project_client.agents
agent = agents_client.create_agent(
model=model_deployment,
name="file-search-agent",
instructions=(
"You are an agent that can search over files using the file sear
ch tool. "
"Use the tool to retrieve snippets or summaries from the indexed
files."
),
tools=[file_search_tool],
tool_resources=[file_search_tool.get_tool_resource()],
)
print(f"Created agent with ID: {agent.id}")
if __name__ == "__main__":
main()
```
**Usage**
- Install the SDK if you haven’t already:
```
pip install azure-ai-projects azure-identity
```
- Export your settings:
```bash
export PROJECT_ENDPOINT="https://<your-endpoint>.openai.azure.com"
export MODEL_DEPLOYMENT_NAME="<your-deployment-name>"
export VECTOR_STORE_ID="<your-vector-store-id>"
```
- Run the script:
```bash
python create_file_search_agent.py
```
This script will create an agent named **file-search-agent** that can query your
files via the FileSearchTool. Let me know if you’d like to add more tools or cu
stomize the instructions!Result
It thinks more, but it seems not understanding what is “Azure AI Agent”
write a python script to create an Azure AI Agent with file search capabilities │
╰─────────────────────────────────────────────────────────────────────────────────────╯
✦ Of course. I'll provide you with a Python script to provision an Azure AI solution that uses Azure AI Search for file
search capabilities, integrated with an Azure OpenAI model. This setup is often what's meant by an "AI Agent" in this
context.
This script will perform the following actions:
1. Create a resource group to hold all the services.
2. Create a storage account and a blob container, then upload a sample document.
3. Create an Azure AI Search service.
4. Create an Azure OpenAI service and deploy a gpt-4 model.
5. Configure a data source, index, and indexer in Azure AI Search to connect to your blob storage and make the files
searchable.
Here are the files I will create for you:
* create_azure_ai_agent.py: The main Python script to create and configure the Azure resources.
* requirements.txt: A file listing the necessary Python packages to run the script.
* .env: A file to store your Azure configuration securely.
* sample-docs/sample-file.txt: A sample file that will be uploaded to your storage for the search service to index.
First, here are the contents for requirements.txt.
╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔ WriteFile Writing to requirements.txt │
│ │
│ 1 azure-identity │
│ 2 azure-mgmt-resource │
│ 3 azure-mgmt-storage │
│ 4 azure-mgmt-search │
│ 5 azure-mgmt-cognitiveservices │
│ 6 azure-search-documents==11.4.0 │
│ 7 azure-storage-blob │
│ 8 python-dotenv │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Next, the .env file for your configuration.
Action Required: You will need to edit this file and replace the placeholder values with your actual Azure Subscription
ID and a unique prefix for the resources that will be created.
╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔ WriteFile Writing to .env │
│ │
│ 1 # Your Azure Subscription ID │
│ 2 AZURE_SUBSCRIPTION_ID="<your-subscription-id>" │
│ 3 │
│ 4 # A unique prefix for all resources that will be created (e.g., "my-ai-agent") │
│ 5 # Use only lowercase letters and numbers │
│ 6 RESOURCE_PREFIX="<your-unique-resource-prefix>" │
│ 7 │
│ 8 # Azure region for deployment │
│ 9 LOCATION="eastus" │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Now, here is a sample document that the script will upload to your storage account. This will be the first file your AI
agent can search.
╭────────────────────────────────────────────────────────────────────────────────────╮
│ ✔ Shell mkdir -p 'sample-docs' (Create a directory to hold the sample document.) │
╰────────────────────────────────────────────────────────────────────────────────────╯
╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔ WriteFile Writing to sample-docs/sample-file.txt │
│ │
│ 1 This is a sample document about Azure AI. │
│ 2 Azure AI is a collection of artificial intelligence (AI) services and APIs from Microsoft. │
│ 3 These services allow developers to easily add AI capabilities to their applications. │
│ 4 The main services include Azure OpenAI, Azure AI Search, and Azure AI Vision. │
│ 5 This document is intended to be indexed by Azure AI Search. │
│ 6 You can ask the AI agent questions about the content of this file. For example: "What is Azure AI?" │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Finally, here is the Python script that ties everything together. It will create and configure all the necessary Azure
resources for your AI agent.
╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔ WriteFile Writing to create_azure_ai_agent.py │
│ │
│ ... first 140 lines hidden ... │
│ 141 │
│ 142 │
│ 143 def create_search_service(client: SearchManagementClient): │
│ 144 """Create an Azure AI Search service.""" │
│ 145 print(f"Creating search service '{SEARCH_SERVICE_NAME}'...") │
│ 146 poller = client.services.begin_create_or_update( │
│ 147 RESOURCE_GROUP_NAME, │
│ 148 SEARCH_SERVICE_NAME, │
│ 149 { │
│ 150 "sku": {"name": "standard"}, │
│ 151 "location": LOCATION, │
│ 152 "properties": {"hostingMode": "default", "publicNetworkAccess": "Enabled"}, │
│ 153 }, │
│ 154 ) │
│ 155 service = poller.result() │
│ 156 print("Search service created.") │
│ 157 return service │
│ 158 │
│ 159 │
│ 160 def create_openai_service(client: CognitiveServicesManagementClient): │
│ 161 """Create an Azure OpenAI service.""" │
│ 162 print(f"Creating OpenAI service '{COGNITIVE_SERVICES_NAME}'...") │
│ 163 poller = client.accounts.begin_create( │
│ 164 RESOURCE_GROUP_NAME, │
│ 165 COGNITIVE_SERVICES_NAME, │
│ 166 { │
│ 167 "sku": {"name": "S0"}, │
│ 168 "kind": "OpenAI", │
│ 169 "location": LOCATION, │
│ 170 }, │
│ 171 ) │
│ 172 poller.result() │
│ 173 print("OpenAI service created.") │
│ 174 │
│ 175 │
│ 176 def deploy_openai_model(client: CognitiveServicesManagementClient): │
│ 177 """Deploy a model to the Azure OpenAI service.""" │
│ 178 print(f"Deploying model '{OPENAI_DEPLOYMENT_NAME}'...") │
│ 179 poller = client.deployments.begin_create_or_update( │
│ 180 RESOURCE_GROUP_NAME, │
│ 181 COGNITIVE_SERVICES_NAME, │
│ 182 OPENAI_DEPLOYMENT_NAME, │
│ 183 { │
│ 184 "sku": {"name": "Standard", "capacity": 1}, │
│ 185 "properties": { │
│ 186 "model": {"format": "OpenAI", "name": "gpt-4", "version": "1106-Preview"} │
│ 187 }, │
│ 188 }, │
│ 189 ) │
│ 190 poller.result() │
│ 191 print("Model deployed.") │
│ 192 │
│ 193 │
│ 194 def create_search_index(client: SearchIndexClient): │
│ 195 """Create a search index.""" │
│ 196 print(f"Creating search index '{INDEX_NAME}'...") │
│ 197 fields = [ │
│ 198 SimpleField(name="id", type=SearchFieldDataType.String, key=True), │
│ 199 SearchableField(name="content", type=SearchFieldDataType.String, searchable=True, filterable= │
│ False, sortable=False, facetable=False), │
│ 200 SimpleField(name="metadata_storage_path", type=SearchFieldDataType.String, filterable=True, │
│ sortable=True, facetable=True), │
│ 201 ] │
│ 202 │
│ 203 semantic_settings = SemanticSettings( │
│ 204 configurations=[ │
│ 205 SemanticConfiguration( │
│ 206 name="default", │
│ 207 prioritized_fields=PrioritizedFields( │
│ 208 title_field=None, │
│ 209 prioritized_content_fields=[SemanticField(field_name="content")] │
│ 210 ), │
│ 211 ) │
│ 212 ] │
│ 213 ) │
│ 214 │
│ 215 index = SearchIndex(name=INDEX_NAME, fields=fields, semantic_settings=semantic_settings) │
│ 216 client.create_or_update_index(index) │
│ 217 print("Search index created.") │
│ 218 │
│ 219 │
│ 220 def create_datasource(client: SearchIndexerClient, connection_string: str): │
│ 221 """Create a data source for the indexer.""" │
│ 222 print(f"Creating data source '{DATA_SOURCE_NAME}'...") │
│ 223 container = SearchIndexerDataContainer(name=BLOB_CONTAINER_NAME) │
│ 224 data_source = SearchIndexerDataSourceConnection( │
│ 225 name=DATA_SOURCE_NAME, │
│ 226 type="azureblob", │
│ 227 connection_string=connection_string, │
│ 228 container=container, │
│ 229 ) │
│ 230 client.create_or_or_update_data_source_connection(data_source) │
│ 231 print("Data source created.") │
│ 232 │
│ 233 │
│ 234 def create_indexer(client: SearchIndexerClient): │
│ 235 """Create an indexer to connect the data source to the index.""" │
│ 236 print(f"Creating indexer '{INDEXER_NAME}'...") │
│ 237 indexer = SearchIndexer( │
│ 238 name=INDEXER_NAME, │
│ 239 data_source_name=DATA_SOURCE_NAME, │
│ 240 target_index_name=INDEX_NAME, │
│ 241 field_mappings=[ │
│ 242 {"sourceFieldName": "metadata_storage_path", "targetFieldName": "id", "mappingFunction": { │
│ "name": "base64Encode"}}, │
│ 243 {"sourceFieldName": "content", "targetFieldName": "content"}, │
│ 244 ], │
│ 245 output_field_mappings=[ │
│ 246 {"sourceFieldName": "/document/metadata_storage_path", "targetFieldName": │
│ "metadata_storage_path"} │
│ 247 ] │
│ 248 ) │
│ 249 client.create_or_update_indexer(indexer) │
│ 250 print("Indexer created. It will now run and index your documents.") │
│ 251 │
│ 252 │
│ 253 if __name__ == "__main__": │
│ 254 main() │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I have created all the necessary files for you. Here's how to use them to create your Azure AI Agent:
Prerequisites
1. Azure Subscription: You need an active Azure subscription.
2. Azure CLI: Install the Azure CLI (https://docs.microsoft.com/en-us/cli/azure/install-azure-cli) and sign in to your
account by running:
1 az login
3. Python: Make sure you have Python 3.8 or later installed.
Setup and Execution
1. Fill in your details:
Open the .env file and replace <your-subscription-id> with your Azure Subscription ID and
<your-unique-resource-prefix> with a unique name (e.g., my-ai-agent-01).
2. Install dependencies:
Open your terminal in the project directory and run the following command to install the required Python packages:
1 pip install -r requirements.txt
3. Run the script:
Execute the main script from your terminal:
1 python create_azure_ai_agent.py
The script will now run and provision all the resources in your Azure account. This process can take several minutes.
Verification and Next Steps
Once the script is finished, you can go to the Azure Portal (https://portal.azure.com) to see the created resources.
You will find a new resource group (e.g., my-ai-agent-01-rg) containing your Storage Account, AI Search service, and
OpenAI service.
* Query your data: Go to your AI Search service in the portal, open the Search explorer, and select your index
(file-search-index). You can now run queries against your indexed file. For example, try searching for What is Azure
AI?.
* Add more files: To add more files to your agent's knowledge base, simply upload them to the file-storage container in
your storage account. The indexer will automatically detect and process them.
* Build a chat application: You can now build a chat application that uses the Azure OpenAI service to understand user
questions and the AI Search service to find relevant information from your files to answer them. This pattern is known
as Retrieval-Augmented Generation (RAG).export CLAUDE_CODE_USE_BEDROCK=1
export AWS_REGION=us-east-1Use Amazon Bedrock short-term API key
export AWS_BEARER_TOKEN_BEDROCK=your-bedrock-api-keyResult
Similar to gemini cli
write a python script to create an Azure AI Agent with file search capabilities
⏺ I'll help you write a Python script to create an Azure AI Agent with file search capabilities. Let me start by creating a plan
using the todo list.
⏺ Update Todos
⎿ ☐ Set up Azure AI client libraries and dependencies
☐ Define the Azure AI Agent class
☐ Implement file search functionality
☐ Create example usage and test the agent
⏺ Let me write a Python script that creates an Azure AI Agent with file search capabilities.
⏺ Update Todos
⎿ ☐ Set up Azure AI client libraries and dependencies
☐ Define the Azure AI Agent class
☐ Implement file search functionality
☐ Create example usage and test the agent
⏺ Write(azure_ai_agent.py)
⎿ Wrote 11 lines to azure_ai_agent.py
#!/usr/bin/env python3
import os
import glob
import re
from typing import List, Dict, Any, Optional
from azure.identity import DefaultAzureCredential
from azure.core.credentials import AzureKeyCredential
from azure.ai.language.conversations import ConversationAnalysisClient
from azure.search.documents import SearchClient
… +1 line (ctrl+r to expand)
⏺ Update Todos
⎿ ☒ Set up Azure AI client libraries and dependencies
☐ Define the Azure AI Agent class
☐ Implement file search functionality
☐ Create example usage and test the agent
⏺ Update(azure_ai_agent.py)
⎿ Updated azure_ai_agent.py with 65 additions and 2 removals
3 import os
4 import glob
5 import re
6 - from typing import List, Dict, Any, Optional
6 + import json
7 + import logging
8 + from typing import List, Dict, Any, Optional, Union
9 +
10 + # Azure AI libraries
11 from azure.identity import DefaultAzureCredential
12 from azure.core.credentials import AzureKeyCredential
13 from azure.ai.language.conversations import ConversationAnalysisClient
14 from azure.search.documents import SearchClient
15 - from azure.search.documents.models import VectorizedQuery
15 \ No newline at end of file
16 + from azure.search.documents.models import VectorizedQuery
17 + from azure.ai.textanalytics import TextAnalyticsClient
18 + from azure.ai.ml import MLClient
19 +
20 + # Set up logging
21 + logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
22 + logger = logging.getLogger(__name__)
23 +
24 +
25 + class AzureAIAgent:
26 + """Azure AI Agent with file search capabilities."""
27 +
28 + def __init__(self,
29 + cognitive_service_endpoint: str,
30 + search_service_endpoint: str,
31 + search_index_name: str,
32 + cognitive_service_key: Optional[str] = None,
33 + search_service_key: Optional[str] = None):
34 + """Initialize the Azure AI Agent.
35 +
36 + Args:
37 + cognitive_service_endpoint: The endpoint for Azure Cognitive Services
38 + search_service_endpoint: The endpoint for Azure Cognitive Search
39 + search_index_name: The name of the search index
40 + cognitive_service_key: Optional API key for Azure Cognitive Services
41 + search_service_key: Optional API key for Azure Cognitive Search
42 + """
43 + self.cognitive_service_endpoint = cognitive_service_endpoint
44 + self.search_service_endpoint = search_service_endpoint
45 + self.search_index_name = search_index_name
46 +
47 + # Set up credentials (either using API keys or DefaultAzureCredential)
48 + if cognitive_service_key:
49 + self.cognitive_credential = AzureKeyCredential(cognitive_service_key)
50 + else:
51 + self.cognitive_credential = DefaultAzureCredential()
52 +
53 + if search_service_key:
54 + self.search_credential = AzureKeyCredential(search_service_key)
55 + else:
56 + self.search_credential = DefaultAzureCredential()
57 +
58 + # Initialize clients
59 + self.text_analytics_client = TextAnalyticsClient(
60 + endpoint=cognitive_service_endpoint,
61 + credential=self.cognitive_credential
62 + )
63 +
64 + self.conversation_client = ConversationAnalysisClient(
65 + endpoint=cognitive_service_endpoint,
66 + credential=self.cognitive_credential
67 + )
68 +
69 + self.search_client = SearchClient(
70 + endpoint=search_service_endpoint,
71 + index_name=search_index_name,
72 + credential=self.search_credential
73 + )
74 +
75 + logger.info("Azure AI Agent initialized successfully")
76 \ No newline at end of file
⏺ Update Todos
⎿ ☒ Set up Azure AI client libraries and dependencies
☒ Define the Azure AI Agent class
☐ Implement file search functionality
☐ Create example usage and test the agent
⏺ Update(azure_ai_agent.py)
⎿ Updated azure_ai_agent.py with 159 additions and 2 removals
29 search_service_endpoint: str,
30 search_index_name: str,
31 cognitive_service_key: Optional[str] = None,
32 - search_service_key: Optional[str] = None):
32 + search_service_key: Optional[str] = None,
33 + local_file_path: Optional[str] = None):
34 """Initialize the Azure AI Agent.
35
36 Args:
...
38 search_index_name: The name of the search index
39 cognitive_service_key: Optional API key for Azure Cognitive Services
40 search_service_key: Optional API key for Azure Cognitive Search
41 + local_file_path: Optional path to search local files
42 """
43 self.cognitive_service_endpoint = cognitive_service_endpoint
44 self.search_service_endpoint = search_service_endpoint
45 self.search_index_name = search_index_name
46 + self.local_file_path = local_file_path or os.getcwd()
47
48 # Set up credentials (either using API keys or DefaultAzureCredential)
49 if cognitive_service_key:
...
71 credential=self.search_credential
72 )
73
74 - logger.info("Azure AI Agent initialized successfully")
74 \ No newline at end of file
75 + logger.info("Azure AI Agent initialized successfully")
76 +
77 + def search_files_in_azure(self, query: str, top: int = 10) -> List[Dict[str, Any]]:
78 + """Search for files in Azure Cognitive Search index.
79 +
80 + Args:
81 + query: The search query
82 + top: Maximum number of results to return
83 +
84 + Returns:
85 + List of search results
86 + """
87 + try:
88 + # Create a vector query if available, otherwise use keyword search
89 + search_results = self.search_client.search(
90 + search_text=query,
91 + top=top,
92 + include_total_count=True
93 + )
94 +
95 + results = []
96 + for result in search_results:
97 + results.append({
98 + "id": result.get("id", ""),
99 + "filename": result.get("filename", ""),
100 + "filepath": result.get("filepath", ""),
101 + "content": result.get("content", ""),
102 + "score": result["@search.score"]
103 + })
104 +
105 + logger.info(f"Found {len(results)} results in Azure search")
106 + return results
107 +
108 + except Exception as e:
109 + logger.error(f"Error searching in Azure: {str(e)}")
110 + return []
111 +
112 + def search_local_files(self,
113 + query: str,
114 + file_extensions: List[str] = None,
115 + max_results: int = 10) -> List[Dict[str, Any]]:
116 + """Search for files locally based on content or filename.
117 +
118 + Args:
119 + query: The search query
120 + file_extensions: List of file extensions to search (e.g., ['.txt', '.py'])
121 + max_results: Maximum number of results to return
122 +
123 + Returns:
124 + List of search results
125 + """
126 + results = []
127 + file_extensions = file_extensions or [".txt", ".py", ".js", ".html", ".css", ".md"]
128 + pattern = "**/*" + "*".join(file_extensions)
129 +
130 + try:
131 + # Get list of files matching extensions
132 + all_files = glob.glob(os.path.join(self.local_file_path, pattern), recursive=True)
133 + logger.info(f"Found {len(all_files)} files with specified extensions")
134 +
135 + # Extract text entities to help with search
136 + response = self.text_analytics_client.extract_key_phrases(
137 + documents=[query],
138 + language="en" # or use language detection
139 + )
140 +
141 + key_phrases = []
142 + for doc in response:
143 + if not doc.is_error:
144 + key_phrases.extend(doc.key_phrases)
145 +
146 + query_terms = set(query.lower().split()) | set(phrase.lower() for phrase in key_phrases)
147 +
148 + # Search through files
149 + for file_path in all_files[:100]: # Limit initial search to prevent timeout
150 + try:
151 + filename = os.path.basename(file_path)
152 + score = 0
153 + content = ""
154 +
155 + # Check filename match first (faster)
156 + for term in query_terms:
157 + if term in filename.lower():
158 + score += 5 # Boost score for filename matches
159 +
160 + # Only check content if filename shows promise or we have few results
161 + if score > 0 or len(results) < max_results:
162 + try:
163 + with open(file_path, 'r', encoding='utf-8') as file:
164 + content = file.read()
165 +
166 + # Check content for query terms
167 + for term in query_terms:
168 + if term in content.lower():
169 + score += 1 + (content.lower().count(term) * 0.1) # Score based on frequency
170 + except UnicodeDecodeError:
171 + # Skip binary files
172 + pass
173 +
174 + if score > 0:
175 + results.append({
176 + "id": file_path,
177 + "filename": filename,
178 + "filepath": file_path,
179 + "content": content[:500] + "..." if len(content) > 500 else content,
180 + "score": score
181 + })
182 + except Exception as file_error:
183 + logger.warning(f"Error processing file {file_path}: {str(file_error)}")
184 +
185 + # Sort by score and limit results
186 + results = sorted(results, key=lambda x: x["score"], reverse=True)[:max_results]
187 + logger.info(f"Found {len(results)} relevant local files")
188 +
189 + return results
190 +
191 + except Exception as e:
192 + logger.error(f"Error searching local files: {str(e)}")
193 + return []
194 +
195 + def search_files(self,
196 + query: str,
197 + search_azure: bool = True,
198 + search_local: bool = True,
199 + file_extensions: List[str] = None,
200 + max_results: int = 10) -> Dict[str, List[Dict[str, Any]]]:
201 + """Search for files in both Azure and locally.
202 +
203 + Args:
204 + query: The search query
205 + search_azure: Whether to search in Azure
206 + search_local: Whether to search locally
207 + file_extensions: List of file extensions for local search
208 + max_results: Maximum number of results to return per source
209 +
210 + Returns:
211 + Dictionary with Azure and local search results
212 + """
213 + azure_results = []
214 + local_results = []
215 +
216 + if search_azure:
217 + azure_results = self.search_files_in_azure(query, top=max_results)
218 +
219 + if search_local:
220 + local_results = self.search_local_files(
221 + query=query,
222 + file_extensions=file_extensions,
223 + max_results=max_results
224 + )
225 +
226 + return {
227 + "azure_results": azure_results,
228 + "local_results": local_results
229 + }
230 \ No newline at end of file
⏺ Update Todos
⎿ ☒ Set up Azure AI client libraries and dependencies
☒ Define the Azure AI Agent class
☒ Implement file search functionality
☐ Create example usage and test the agent
⏺ Update(azure_ai_agent.py)
⎿ Updated azure_ai_agent.py with 10 additions
20 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
21 logger = logging.getLogger(__name__)
22
23 + # Configuration with default values
24 + DEFAULT_CONFIG = {
25 + "cognitive_service_endpoint": "",
26 + "search_service_endpoint": "",
27 + "search_index_name": "file-index",
28 + "local_file_path": ".",
29 + "file_extensions": [".txt", ".py", ".js", ".html", ".css", ".md"],
30 + "max_results": 10
31 + }
32
33 +
34 class AzureAIAgent:
35 """Azure AI Agent with file search capabilities."""
36
⏺ Update(azure_ai_agent.py)
⎿ Updated azure_ai_agent.py with 1 addition and 1 removal
37 def __init__(self,
38 cognitive_service_endpoint: str,
39 search_service_endpoint: str,
40 - search_index_name: str,
40 + search_index_name: str = DEFAULT_CONFIG["search_index_name"],
41 cognitive_service_key: Optional[str] = None,
42 search_service_key: Optional[str] = None,
43 local_file_path: Optional[str] = None):
⏺ Write(example_usage.py)
⎿ Wrote 81 lines to example_usage.py
#!/usr/bin/env python3
import os
import json
from dotenv import load_dotenv
from azure_ai_agent import AzureAIAgent
# Load environment variables from .env file
load_dotenv()
… +71 lines (ctrl+r to expand)
⏺ Write(.env.example)
⎿ Wrote 9 lines to .env.example
# Azure AI services configuration
AZURE_COGNITIVE_SERVICE_ENDPOINT=https://your-cognitive-service.cognitiveservices.azure.com/
AZURE_COGNITIVE_SERVICE_KEY=your_cognitive_service_key_here
AZURE_SEARCH_SERVICE_ENDPOINT=https://your-search-service.search.windows.net/
AZURE_SEARCH_SERVICE_KEY=your_search_service_key_here
AZURE_SEARCH_INDEX_NAME=file-index
# Local file search configuration
LOCAL_FILE_PATH=.
⏺ Write(README.md)
⎿ Wrote 84 lines to README.md
# Azure AI Agent with File Search Capabilities
This Python script creates an Azure AI Agent that can search for files both in Azure Cognitive Search and locally on your
filesystem.
## Features
- Search files in Azure Cognitive Search
- Search local files based on content or filename
- Filter by file extensions
- Combine Azure and local search results
… +74 lines (ctrl+r to expand)
⏺ Update Todos
⎿ ☒ Set up Azure AI client libraries and dependencies
☒ Define the Azure AI Agent class
☒ Implement file search functionality
☒ Create example usage and test the agent
⏺ I've created a Python script that implements an Azure AI Agent with file search capabilities. The implementation includes:
1. azure_ai_agent.py - Main agent class with Azure and local file search functionality
2. example_usage.py - Example script showing how to use the agent
3. .env.example - Configuration template for Azure credentials
4. README.md - Documentation on setup and usage
To use the agent, install the required dependencies and configure your Azure credentials in a .env file. The agent can search
both in Azure Cognitive Search and local files, with customizable file extensions and result limits.
