SharePoint + RAG: Leverage Your Microsoft 365 Documents

SharePoint is the document vault for millions of enterprises. Procedures, contracts, presentations, reports: everything ends up in SharePoint. But this wealth quickly becomes a hindrance. Finding a specific document among gigabytes of files is a struggle. Native search doesn't understand natural language questions and is limited to exact keywords.

A RAG assistant connected to SharePoint changes everything. It understands the meaning of your questions, explores your documents deeply, and synthesizes answers with relevant sources. This guide walks you through this critical integration for Microsoft 365 environments.

Why SharePoint Search Is Problematic

Daily Frustrations

SharePoint users know these situations:

• Limited keyword search: "How to request time off" doesn't find "absence procedure"
• Drowning in results: Hundreds of documents for a simple query
• Multiple versions: Which is the right document among 5 versions?
• No synthesis: Must open and read each file
• Heterogeneous formats: PDF, Word, Excel, PowerPoint... hard to browse

Revealing Statistics

SharePoint Search vs RAG

SharePoint + RAG Architecture

The integration relies on Microsoft Graph API for extraction and a RAG pipeline for indexing and querying.

+-------------------------------------------------------------------------+
|                     SharePoint + RAG Architecture                        |
+-------------------------------------------------------------------------+
|                                                                         |
|   MICROSOFT 365                EXTRACTION                  PROCESSING   |
|   +--------------+            +--------------+          +------------+  |
|   |  SharePoint  |----------->| Graph API    |--------->|  Parsing   |  |
|   |              |            |              |          |            |  |
|   |  - Sites     |            |  /sites      |          |  PDF->Text |  |
|   |  - Libraries |            |  /drives     |          |  DOCX->MD  |  |
|   |  - Documents |            |  /items      |          |  XLSX->CSV |  |
|   +--------------+            +--------------+          +------+-----+  |
|                                                                |        |
|   +--------------+                                      +------+-----+  |
|   |   OneDrive   |--------------------------------------|  Chunking  |  |
|   |   Teams      |                                      |  512 tok   |  |
|   +--------------+                                      +------+-----+  |
|                                                                |        |
|                                                         +------+-----+  |
|   VECTOR DB                                             | Embeddings |  |
|   +--------------+                                      |  BGE-M3    |  |
|   |    Qdrant    |<-------------------------------------+------+-----+  |
|   |              |                                                      |
|   |  HNSW Index  |                                                      |
|   +------+-------+                                                      |
|          |                                                              |
|   QUERY  |                                                              |
|   +------+-------+     +-------------+     +--------------+             |
|   |   Question   |---->|  Retrieval  |---->|   Reranker   |             |
|   |  user        |     |   Top-30    |     |    Top-5     |             |
|   +--------------+     +-------------+     +------+-------+             |
|                                                   |                     |
|                        +--------------+    +------+-------+             |
|                        |   Response   |<---|     LLM      |             |
|                        |  + Sources   |    | GPT-4/Claude |             |
|                        +--------------+    +--------------+             |
|                                                                         |
+-------------------------------------------------------------------------+

Data Flow

1. Authentication: OAuth2 with Microsoft Entra ID (Azure AD)
2. Extraction: Microsoft Graph API retrieves files from sites/drives
3. Parsing: Office format conversion to exploitable text
4. Chunking: Splitting into 512-token segments
5. Embedding: Vectorization with BGE-M3 (multilingual)
6. Indexing: Storage in Qdrant with rich metadata
7. Retrieval: Semantic search on questions
8. Generation: LLM synthesizes with citations

Complete SharePoint Connector

Here's the reference implementation using Microsoft Graph:

DEVELOPERpython
import msal
import requests
from typing import Optional, List
import hashlib
from io import BytesIO

# Parsers for Office formats
from pypdf import PdfReader
from docx import Document
import openpyxl
from pptx import Presentation

class SharePointConnector:
    def __init__(
        self,
        tenant_id: str,
        client_id: str,
        client_secret: str,
        site_url: str = None
    ):
        """
        Initialize SharePoint connector via Microsoft Graph.

        Args:
            tenant_id: Azure AD tenant ID
            client_id: Registered application ID
            client_secret: Application secret
            site_url: SharePoint site URL (optional)
        """
        self.tenant_id = tenant_id
        self.client_id = client_id
        self.client_secret = client_secret
        self.site_url = site_url
        self.graph_url = "https://graph.microsoft.com/v1.0"
        self._token = None

    def _get_token(self) -> str:
        """Get access token via MSAL."""
        if self._token:
            return self._token

        app = msal.ConfidentialClientApplication(
            self.client_id,
            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
            client_credential=self.client_secret
        )

        result = app.acquire_token_for_client(
            scopes=["https://graph.microsoft.com/.default"]
        )

        if "access_token" in result:
            self._token = result["access_token"]
            return self._token
        else:
            raise Exception(f"Auth error: {result.get('error_description')}")

    def _graph_request(self, endpoint: str, params: dict = None) -> dict:
        """Execute a Graph API request."""
        headers = {
            "Authorization": f"Bearer {self._get_token()}",
            "Content-Type": "application/json"
        }

        response = requests.get(
            f"{self.graph_url}{endpoint}",
            headers=headers,
            params=params
        )
        response.raise_for_status()
        return response.json()

    def get_sites(self) -> List[dict]:
        """Retrieve all accessible SharePoint sites."""
        sites = []
        endpoint = "/sites?search=*"

        while endpoint:
            result = self._graph_request(endpoint)
            sites.extend(result.get('value', []))
            endpoint = result.get('@odata.nextLink', '').replace(self.graph_url, '')

        return [
            {
                'id': site['id'],
                'name': site['displayName'],
                'url': site['webUrl'],
                'description': site.get('description', '')
            }
            for site in sites
        ]

    def get_document_libraries(self, site_id: str) -> List[dict]:
        """Retrieve document libraries from a site."""
        result = self._graph_request(f"/sites/{site_id}/drives")

        return [
            {
                'id': drive['id'],
                'name': drive['name'],
                'type': drive.get('driveType'),
                'quota': drive.get('quota', {})
            }
            for drive in result.get('value', [])
        ]

    def get_all_files(self, site_id: str, drive_id: str) -> List[dict]:
        """
        Recursively retrieve all files from a library.
        """
        files = []
        self._traverse_folder(site_id, drive_id, "root", files)
        return files

    def _traverse_folder(
        self,
        site_id: str,
        drive_id: str,
        folder_id: str,
        files: list,
        path: str = ""
    ):
        """Recursive folder traversal."""
        endpoint = f"/sites/{site_id}/drives/{drive_id}/items/{folder_id}/children"
        result = self._graph_request(endpoint)

        for item in result.get('value', []):
            item_path = f"{path}/{item['name']}" if path else item['name']

            if 'folder' in item:
                # It's a folder, descend
                self._traverse_folder(
                    site_id, drive_id, item['id'], files, item_path
                )
            elif 'file' in item:
                # It's a file
                file_info = {
                    'id': item['id'],
                    'name': item['name'],
                    'path': item_path,
                    'size': item.get('size', 0),
                    'mime_type': item['file'].get('mimeType'),
                    'created': item.get('createdDateTime'),
                    'modified': item.get('lastModifiedDateTime'),
                    'created_by': item.get('createdBy', {}).get('user', {}).get('displayName'),
                    'modified_by': item.get('lastModifiedBy', {}).get('user', {}).get('displayName'),
                    'download_url': item.get('@microsoft.graph.downloadUrl'),
                    'web_url': item.get('webUrl')
                }
                files.append(file_info)

    def download_file(self, download_url: str) -> bytes:
        """Download file content."""
        response = requests.get(download_url)
        response.raise_for_status()
        return response.content

    def extract_document_content(self, file_info: dict) -> Optional[dict]:
        """
        Extract textual content from a document.

        Supports: PDF, DOCX, XLSX, PPTX, TXT, MD
        """
        if not file_info.get('download_url'):
            return None

        mime_type = file_info.get('mime_type', '')
        name = file_info['name'].lower()

        try:
            content_bytes = self.download_file(file_info['download_url'])
            text_content = ""

            # PDF
            if mime_type == 'application/pdf' or name.endswith('.pdf'):
                text_content = self._parse_pdf(content_bytes)

            # Word
            elif 'wordprocessingml' in mime_type or name.endswith('.docx'):
                text_content = self._parse_docx(content_bytes)

            # Excel
            elif 'spreadsheetml' in mime_type or name.endswith('.xlsx'):
                text_content = self._parse_xlsx(content_bytes)

            # PowerPoint
            elif 'presentationml' in mime_type or name.endswith('.pptx'):
                text_content = self._parse_pptx(content_bytes)

            # Plain text
            elif mime_type.startswith('text/') or name.endswith(('.txt', '.md', '.csv')):
                text_content = content_bytes.decode('utf-8', errors='ignore')

            else:
                return None  # Unsupported format

            if not text_content or len(text_content) < 50:
                return None

            content_hash = hashlib.md5(text_content.encode()).hexdigest()

            return {
                'id': f"sharepoint_{file_info['id']}",
                'title': file_info['name'],
                'content': f"# {file_info['name']}\n\n**Path**: {file_info['path']}\n\n{text_content}",
                'metadata': {
                    'source': 'sharepoint',
                    'source_type': 'document',
                    'file_id': file_info['id'],
                    'file_name': file_info['name'],
                    'file_path': file_info['path'],
                    'file_size': file_info['size'],
                    'mime_type': file_info['mime_type'],
                    'url': file_info['web_url'],
                    'created': file_info['created'],
                    'modified': file_info['modified'],
                    'created_by': file_info['created_by'],
                    'modified_by': file_info['modified_by'],
                    'content_hash': content_hash
                }
            }

        except Exception as e:
            print(f"Extraction error {file_info['name']}: {e}")
            return None

    def _parse_pdf(self, content: bytes) -> str:
        """Extract text from PDF."""
        reader = PdfReader(BytesIO(content))
        text_parts = []

        for page in reader.pages:
            text = page.extract_text()
            if text:
                text_parts.append(text)

        return '\n\n'.join(text_parts)

    def _parse_docx(self, content: bytes) -> str:
        """Extract text from DOCX."""
        doc = Document(BytesIO(content))
        paragraphs = []

        for para in doc.paragraphs:
            if para.text.strip():
                # Detect headings
                if para.style.name.startswith('Heading'):
                    level = int(para.style.name[-1]) if para.style.name[-1].isdigit() else 1
                    paragraphs.append(f"{'#' * level} {para.text}")
                else:
                    paragraphs.append(para.text)

        # Extract tables
        for table in doc.tables:
            table_text = self._docx_table_to_markdown(table)
            paragraphs.append(table_text)

        return '\n\n'.join(paragraphs)

    def _docx_table_to_markdown(self, table) -> str:
        """Convert Word table to Markdown."""
        rows = []
        for i, row in enumerate(table.rows):
            cells = [cell.text.replace('|', '\\|') for cell in row.cells]
            rows.append('| ' + ' | '.join(cells) + ' |')
            if i == 0:
                rows.append('| ' + ' | '.join(['---'] * len(cells)) + ' |')
        return '\n'.join(rows)

    def _parse_xlsx(self, content: bytes) -> str:
        """Extract content from Excel."""
        workbook = openpyxl.load_workbook(BytesIO(content), data_only=True)
        sheets_content = []

        for sheet_name in workbook.sheetnames:
            sheet = workbook[sheet_name]
            sheet_text = [f"## Sheet: {sheet_name}"]

            # Convert to markdown table
            rows = []
            for i, row in enumerate(sheet.iter_rows(values_only=True)):
                if any(cell is not None for cell in row):
                    cells = [str(cell) if cell else '' for cell in row]
                    rows.append('| ' + ' | '.join(cells) + ' |')
                    if i == 0:
                        rows.append('| ' + ' | '.join(['---'] * len(cells)) + ' |')

            sheet_text.append('\n'.join(rows))
            sheets_content.append('\n'.join(sheet_text))

        return '\n\n'.join(sheets_content)

    def _parse_pptx(self, content: bytes) -> str:
        """Extract text from PowerPoint."""
        prs = Presentation(BytesIO(content))
        slides_content = []

        for i, slide in enumerate(prs.slides, 1):
            slide_text = [f"## Slide {i}"]

            for shape in slide.shapes:
                if hasattr(shape, 'text') and shape.text.strip():
                    slide_text.append(shape.text)

            slides_content.append('\n\n'.join(slide_text))

        return '\n\n---\n\n'.join(slides_content)

Permission Management

SharePoint has complex permissions. RAG must respect them:

DEVELOPERpython
class SharePointPermissionManager:
    def __init__(self, connector: SharePointConnector):
        self.connector = connector

    def get_item_permissions(self, site_id: str, item_id: str) -> dict:
        """Retrieve item permissions."""
        endpoint = f"/sites/{site_id}/drive/items/{item_id}/permissions"
        result = self.connector._graph_request(endpoint)

        permissions = []
        for perm in result.get('value', []):
            if 'grantedToV2' in perm:
                granted = perm['grantedToV2']
                if 'user' in granted:
                    permissions.append({
                        'type': 'user',
                        'id': granted['user'].get('id'),
                        'email': granted['user'].get('email'),
                        'roles': perm.get('roles', [])
                    })
                elif 'group' in granted:
                    permissions.append({
                        'type': 'group',
                        'id': granted['group'].get('id'),
                        'name': granted['group'].get('displayName'),
                        'roles': perm.get('roles', [])
                    })

        return permissions

    def user_can_access(self, user_email: str, doc_permissions: list) -> bool:
        """Check if user can access a document."""
        for perm in doc_permissions:
            if perm['type'] == 'user' and perm['email'] == user_email:
                return True
            # For groups, would need to check membership
        return False

Incremental Synchronization

DEVELOPERpython
from datetime import datetime, timedelta

class SharePointSyncManager:
    def __init__(self, connector: SharePointConnector, indexer):
        self.connector = connector
        self.indexer = indexer
        self.last_sync = None
        self.last_sync_token = None

    def sync_incremental(self, site_id: str, drive_id: str):
        """Synchronize only modified files."""
        # Use delta query for changes
        endpoint = f"/sites/{site_id}/drives/{drive_id}/root/delta"

        if self.last_sync_token:
            # Add change token
            endpoint += f"?token={self.last_sync_token}"

        result = self.connector._graph_request(endpoint)
        changes = result.get('value', [])

        updated = 0
        deleted = 0

        for item in changes:
            if item.get('deleted'):
                # File deleted
                self.indexer.delete_document(f"sharepoint_{item['id']}")
                deleted += 1
            elif 'file' in item:
                # File modified or added
                file_info = {
                    'id': item['id'],
                    'name': item['name'],
                    'path': item.get('parentReference', {}).get('path', ''),
                    'size': item.get('size', 0),
                    'mime_type': item['file'].get('mimeType'),
                    'modified': item.get('lastModifiedDateTime'),
                    'download_url': item.get('@microsoft.graph.downloadUrl'),
                    'web_url': item.get('webUrl')
                }
                doc = self.connector.extract_document_content(file_info)
                if doc:
                    self.indexer.upsert_document(doc)
                    updated += 1

        # Save token for next sync
        delta_link = result.get('@odata.deltaLink', '')
        if 'token=' in delta_link:
            self.last_sync_token = delta_link.split('token=')[-1]

        self.last_sync = datetime.now()
        print(f"Sync: {updated} updated, {deleted} deleted")

Concrete Use Cases

1. Contract Search

Question: "What are the termination conditions for the Supplier X contract?"

RAG Response:

According to the framework contract signed on 03/15/2024:

• Termination notice: 3 months
• Conditions: Registered letter with acknowledgment
• Penalties: 10% of remaining amount for early termination
• Exception: Immediate termination in case of serious breach

Source: [Contracts > Supplier X > Framework-Contract-2024.pdf] (pages 12-13)

2. Internal Procedures

Question: "How do I file an expense report?"

RAG Response:

Expense report procedure:

1. Fill out form NDF-2024.xlsx
2. Attach scanned receipts
3. Submit via HR portal
4. Manager validation within 5 days

Limits: 50 EUR/meal, 150 EUR/night hotel

Source: [HR > Procedures > Expense-report-procedure.docx]

3. Technical Documentation

Question: "How to configure SSO with Azure AD?"

RAG Response:

Azure AD SSO configuration:

1. Create an Enterprise Application in Azure
2. Configure SAML with provided endpoints
3. Map user attributes
4. Test with a test account

See detailed guide for screenshots.

Source: [IT > Documentation > SSO-Azure-AD-Setup.pptx]

Best Practices

Structure SharePoint for RAG

Optimize Indexing

• Exclude temporary and archive folders
• Prioritize text formats (PDF, Word)
• Limit file sizes (< 50 MB)
• Update daily via delta sync

Related Resources

• Enterprise Knowledge Base - Pillar guide
• Notion + RAG - For Notion teams
• Confluence + RAG - For Atlassian
• Introduction to RAG - The fundamentals

---

Connect SharePoint with Ailog

Unlock the potential of your Microsoft 365 documents. Ailog offers:

• Microsoft Graph connector: Native SharePoint and OneDrive integration
• Multi-format parsing: PDF, Word, Excel, PowerPoint
• Permission respect: Conditional access per user
• Incremental sync: Automatic document updates
• French hosting: Native GDPR compliance

Try Ailog for free and make your SharePoint documents AI-queryable in 20 minutes.