💡
Up to this point, we have explored how to create a RAG pattern using a low-code/no-code solution. We will now proceed with the code-first approach, which offers more flexibility and customization options for developers who want fine-grained control over their RAG implementation.
---
## Approach 2: Code-First Implementation
### Azure AI Foundry SDK / AI Projects client library
We'll primarily use the
💡
Following Microsoft’s Build announcement in April 2025, numerous enhancements were introduced to the Azure AI Foundry “Projects” library. If you're using earlier versions, it's highly recommended to upgrade to the latest library . Also note I am using new foundry based project path and not hub based project (legacy) path.
**Install the libraries** - (Note that the dependent package [azure-ai-agents](https://pypi.org/project/azure-ai-agents/) [will be install](https://pypi.org/project/azure-ai-agents/) as a result, if not already installed, to support `.agent` operations on the client.)
```python
!pip install --upgrade azure-ai-projects azure-identity load_dotenv
!python -m pip install --upgrade pip
```
This code loads configuration values (like client ID, secret, tenant ID, and endpoint) from an external `.env` file (`api_settings.env`) into Python variables.
```python
import os
from dotenv import load_dotenv
load_dotenv('api_settings.env')
CLIENT_ID = os.getenv("CLIENT_ID")
CLIENT_SECRET = os.getenv("CLIENT_SECRET")
TENANT_ID = os.getenv("TENANT_ID")
PROJECT_ENDPOINT = os.getenv("PROJECT_ENDPOINT")
```
The script below demonstrates the following steps.
* **Authentication and Setup** – The script retrieves Azure credentials (Tenant ID, Client ID, Client Secret) from environment variables and authenticates using `ClientSecretCredential`. It then initializes the `AIProjectClient` with the given project endpoint.
> When using the Azure AI Projects library with Entra ID authentication, we must authenticate via a service principal or app registration. To enable this, assign the **Azure AI User** role (built-in Azure RBAC role) on the Azure AI Foundry resource to your identity. This ensures your service principal has permission to access AI projects using Microsoft Entra ID.
* **Connection Discovery** – It queries the list of configured project connections and identifies the **Azure AI Search** resource by inspecting connection metadata, extracting the corresponding `connection_id`.
* **Tool Initialization** – An `AzureAISearchTool` instance is created using the connection ID and a predefined index name, enabling integration of search capabilities into the agent.
* **Agent Creation** – A new agent is provisioned with the GPT-4.1-mini model, custom instructions for Retrieval-Augmented Generation (RAG) queries, and the AI Search tool attached as a resource.
* **Thread Creation** – A dedicated conversation thread is established to maintain the dialogue state with the agent.
* **Interactive Execution Loop** –
* User inputs are continuously read from the console.
* Inputs are posted as messages to the agent.
* The agent is executed (`create_and_process`), responses are retrieved, and results are displayed.
* The loop terminates when the user enters `"end"`, after which the agent is deleted for cleanup.
```python
import os
from azure.ai.projects import AIProjectClient
from azure.identity import ClientSecretCredential
from azure.ai.agents.models import AzureAISearchTool
# Entry point for the script
if __name__ == "__main__":
# Load Azure credentials from environment variables
credential = ClientSecretCredential(
tenant_id=os.getenv("TENANT_ID"),
client_id=os.getenv("CLIENT_ID"),
client_secret=os.getenv("CLIENT_SECRET")
)
# Create a client instance for interacting with the Azure AI Project
project_client = AIProjectClient(
credential=credential,
endpoint=os.environ["PROJECT_ENDPOINT"] # Project endpoint reference
)
# Retrieve available project connections to locate the AI Search resource
conn_list = project_client.connections.list()
conn_id = ""
# Identify the Azure AI Search connection by checking metadata fields
# Assumes only one AI Search connection is configured in the project
for conn in conn_list:
properties = conn.get("properties", {})
metadata = properties.get("metadata", {})
if metadata.get("type", "").upper() == "AZURE AI SEARCH":
conn_id = conn["id"]
break
print(conn_id)
# Reassign the valid connection ID for AI Search
conn_id = conn["id"]
# Configure the Azure AI Search tool with the discovered connection and index name
ai_search = AzureAISearchTool(index_connection_id=conn_id, index_name="rag-1754502262882")
# Provision an AI Agent and attach the AI Search tool for RAG-style queries
agent = project_client.agents.create_agent(
model="gpt-4.1-mini",
name="my-agent-aisearch",
instructions="You are a helpful agent to perform RAG Queries using AI Search",
tools=ai_search.definitions,
tool_resources=ai_search.resources,
)
print(f"Created agent, ID: {agent.id}")
# Initialize a new conversation thread for maintaining dialog state
thread = project_client.agents.threads.create()
print(f"Created thread, ID: {thread.id}")
# Continuous user interaction loop
while True:
user_input = input("User: ")
if user_input.lower() == "end":
project_client.agents.delete_agent(agent.id)
print("Ending the conversation.")
break
# Post user input as a message to the agent
message = project_client.agents.messages.create(
thread_id=thread.id,
role="user",
content=user_input,
)
# Run the agent and process the response
run = project_client.agents.runs.create_and_process(thread_id=thread.id, agent_id=agent.id)
print(f"Run finished with status: {run.status}")
if run.status == "failed":
print(f"Run failed: {run.last_error}")
break
# Fetch and print the agent’s most recent reply
messages = project_client.agents.messages.list(thread_id=thread.id)
for agent_response in messages:
if agent_response.text_messages:
last_text = agent_response.text_messages[-1]
print(f"{agent_response.role}: {last_text.text.value}")
# Final cleanup of the agent instance
project_client.agents.delete_agent(agent.id)
print("Conversation ended")
```
## Showcase **\- \[ 02 \] with Visual Studio code in locally**
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1755543484412/95b72106-55ad-456c-a7f9-9deb638678a3.gif align="center")
## Showcase **\- \[ 03 \] using Streamlit Frontend**
> **Streamlit** is an open-source Python framework that makes it easy to build interactive web apps for data and machine learning projects.
📤I deployed my project on **Streamlit Community Cloud** and adapted the code to work seamlessly with the **Streamlit** frontend. This enables me to access the app from anywhere through a customized, user-friendly interface.
By the way, what key information are you looking to extract from that [Microsoft whitepaper?](https://adoption.microsoft.com/files/copilot-studio/Agent-governance-whitepaper.pdf) 📄🤔
I’ve made it public 🌍, so feel free to give it a try 🚀.
**\[ Sample Q’s you can try out for:**
* What specific governance controls do we need to implement for each type of agent creator (End Users, Makers, and Developers) in our organization?
* How can we effectively use Microsoft Purview's Data Loss Prevention policies to prevent our agents from accessing highly confidential SharePoint content?
* What's the best approach for setting up Power Platform environments and pipelines to ensure secure agent development and deployment across our teams? etc \]
> Link : [https://ragaifoundry.streamlit.app/](https://ragaifoundry.streamlit.app/)
> If you’re unable to access the working site, it’s probably because my Azure free credits ran out 💳⚡. You can still find all my project assets in the References section below 📂
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1755580601209/6821edc3-1fbc-4dd3-89d2-4c7cfcf4becd.gif align="center")
## Key Takeaways
Building enterprise RAG solutions with Azure AI Foundry reveals several crucial insights: prioritize data quality over complexity, leverage hybrid search for optimal results, and choose between low-code UI approaches for rapid prototyping or code-first methods for customization. Most importantly, start small and scale gradually while continuously monitoring performance.
## Conclusion
Azure AI Foundry transforms enterprise RAG implementation from complex to accessible. Whether you prefer UI-based configuration, programmatic development, or web deployment, the platform provides enterprise-grade security and scalability without sacrificing ease of use.
The three approaches demonstrated ***Agent playground, Azure AI Foundry SDK, and Streamlit web app*** showcase the platform's flexibility for different team needs and technical requirements. As organizations increasingly need AI solutions that integrate seamlessly with existing Microsoft infrastructure, Azure AI Foundry offers both immediate value and long-term strategic advantages.
---
## References
* [Azure AI Search - Retrieval Augmented Generation Overview](https://learn.microsoft.com/en-us/azure/search/retrieval-augmented-generation-overview?tabs=docs)
* [Azure AI Foundry - RAG Concepts](https://learn.microsoft.com/en-us/azure/ai-foundry/concepts/retrieval-augmented-generation)
* [Microsoft AI Agents Governance Whitepaper](https://adoption.microsoft.com/files/copilot-studio/Agent-governance-whitepaper.pdf)
* [Project Assets](https://github.com/nalakan/AI_Foundry_rag_doc_search?tab=readme-ov-file#rag-based-intelligent-document-search-using-azure-ai-foundrysearch)
---
*Thanks for reading! If you found this guide helpful, consider sharing it with others who might benefit from implementing RAG solutions in their organizations with Microsoft AI Foundry.*