Poor results with GraphRAG setup on Azure (worse than semantic search)

[benifbond]

Hi Maintainers,

I’ve recently started experimenting with GraphRAG because our traditional semantic search results have been quite poor. I followed the workflow from the documentation with a few adjustments (see details below).

After running the indexing, I noticed that it created blob files and three vector indexes on Azure:

graphrag-community-full_content

graphrag-entity-description

graphrag-text_unit-text

Code snippet settings.yaml:

models:
  default_chat_model:
    type: azure_openai_chat # or azure_openai_chat
    api_base: ${AZURE_OPENAI_ENDPOINT}
    api_version: '2024-12-01-preview'
    auth_type: azure_managed_identity # or azure_managed_identity
    # set this in the generated .env file
    # audience: "https://cognitiveservices.azure.com/.default"
    # organization: <organization_id>
    model: gpt-4o
    deployment_name: 'gpt-4o' # Your chat model deployment name
    # encoding_model: cl100k_base # automatically set by tiktoken if left undefined
    model_supports_json: true # recommended if this is available for your model.
    concurrent_requests: 25 # max number of simultaneous LLM requests allowed
    async_mode: threaded # or asyncio
    retry_strategy: native
    max_retries: 10
    tokens_per_minute: auto # set to null to disable rate limiting
    requests_per_minute: auto # set to null to disable rate limiting
  default_embedding_model:
    type: azure_openai_embedding # Or azure_openai_embedding for embeddings
    api_base: ${AZURE_OPENAI_ENDPOINT}
    api_version: '2024-12-01-preview' # You can customize this for other versions
    deployment_name: 'text-embedding-ada-002' # Your embedding model deployment name
    auth_type: azure_managed_identity # or azure_managed_identity

    # audience: "https://cognitiveservices.azure.com/.default"
    # organization: <organization_id>
    model: text-embedding-ada-002
    # deployment_name: <azure_model_deployment_name>
    # encoding_model: cl100k_base # automatically set by tiktoken if left undefined
    model_supports_json: true # recommended if this is available for your model.
    concurrent_requests: 25 # max number of simultaneous LLM requests allowed
    async_mode: threaded # or asyncio
    retry_strategy: native
    max_retries: 10
    tokens_per_minute: null # set to null to disable rate limiting or auto for dynamic
    requests_per_minute:
      null
      # set to null to disable rate limiting or auto for dynamic

### Input settings ###

input:
  storage:
    type: file # or blob
    base_dir: 'input'
  file_type: text

chunks:
  size: 1200
  overlap: 100
  group_by_columns: [id]

### Output/storage settings ###
## If blob storage is specified in the following four sections,
## connection_string and container_name must be provided

output:
  type: blob # [file, blob, cosmosdb]
  base_dir: 'output'
  connection_string: ${BLOB_CONNECTION_STRING}
  container_name: ${BLOB_CONTAINER_NAME}
cache:
  type: blob # [file, blob, cosmosdb]
  base_dir: 'cache'
  connection_string: ${BLOB_CONNECTION_STRING}
  container_name: ${BLOB_CONTAINER_NAME}

reporting:
  type: blob # [file, blob, cosmosdb]
  base_dir: 'logs'
  connection_string: ${BLOB_CONNECTION_STRING}
  container_name: ${BLOB_CONTAINER_NAME}

vector_store:
  default_vector_store:
    type: azure_ai_search
    url: https://chat-search.search.windows.net
    container_name: graphrag
    api_key: ${AZURE_SEARCH_API_KEY}
    overwrite: True

### Workflow settings ###

embed_text:
  model_id: default_embedding_model
  vector_store_id: default_vector_store

extract_graph:
  model_id: default_chat_model
  prompt: 'prompts/extract_graph.txt'
  entity_types: [organization, person, geo, event]
  max_gleanings: 1

summarize_descriptions:
  model_id: default_chat_model
  prompt: 'prompts/summarize_descriptions.txt'
  max_length: 500

extract_graph_nlp:
  text_analyzer:
    extractor_type: regex_english # [regex_english, syntactic_parser, cfg]

cluster_graph:
  max_cluster_size: 10

extract_claims:
  enabled: false
  model_id: default_chat_model
  prompt: 'prompts/extract_claims.txt'
  description: 'Any claims or facts that could be relevant to information discovery.'
  max_gleanings: 1

community_reports:
  model_id: default_chat_model
  graph_prompt: 'prompts/community_report_graph.txt'
  text_prompt: 'prompts/community_report_text.txt'
  max_length: 2000
  max_input_length: 8000

embed_graph:
  enabled: true # if true, will generate node2vec embeddings for nodes

umap:
  enabled: true # if true, will generate UMAP embeddings for nodes (embed_graph must also be enabled)

snapshots:
  graphml: true
  embeddings: false

### Query settings ###
## The prompt locations are required here, but each search method has a number of optional knobs that can be tuned.
## See the config docs: https://microsoft.github.io/graphrag/config/yaml/#query

local_search:
  chat_model_id: default_chat_model
  embedding_model_id: default_embedding_model
  prompt: 'prompts/local_search_system_prompt.txt'

global_search:
  chat_model_id: default_chat_model
  map_prompt: 'prompts/global_search_map_system_prompt.txt'
  reduce_prompt: 'prompts/global_search_reduce_system_prompt.txt'
  knowledge_prompt: 'prompts/global_search_knowledge_system_prompt.txt'

drift_search:
  chat_model_id: default_chat_model
  embedding_model_id: default_embedding_model
  prompt: 'prompts/drift_search_system_prompt.txt'
  reduce_prompt: 'prompts/drift_search_reduce_prompt.txt'

basic_search:
  chat_model_id: default_chat_model
  embedding_model_id: default_embedding_model
  prompt: 'prompts/basic_search_system_prompt.txt'

The issue is that my responses are actually worse than what I got with semantic search:

1. The answers don’t reference the titles of the original text files the information was extracted from.
2. The relevance/quality of the answers is poor.
3. There are high inconsistencies in the response

Note: I used a many .txt files for the embedding

I’ve looked around online, but most tutorials show how to run GraphRAG locally, not with Azure. I’m not sure where in my setup I might have gone wrong.

Code snippet (query):

import os
import json
from typing import Dict, Any, List, Optional
from dataclasses import dataclass

# Azure AI Search imports
from azure.search.documents import SearchClient
from azure.core.credentials import AzureKeyCredential

from services.azure_logger import log_to_azure
import openai



@dataclass
class GraphRAGQueryResult:
    """Result from a GraphRAG query."""
    content: str
    source: str
    score: Optional[float] = None
    metadata: Optional[Dict[str, Any]] = None


class GraphRAGService:
    """
    Service for querying GraphRAG indexes using Azure AI Search.
    
    This service provides a production-ready interface for querying pre-built
    GraphRAG indexes stored in Azure AI Search. It supports multiple query modes
    and handles connection management automatically.
    """
    
    def __init__(self, secrets: Dict[str, str]):
        """
        Initialize the GraphRAG service.
        
        Args:
            secrets (Dict[str, str]): Dictionary containing Azure service credentials
        """
        self.secrets = secrets
        self._search_clients = {}
        self._openai_client: openai.AzureOpenAI | None = None
        # Query/runtime knobs (lightweight alignment with GraphRAG docs)
        self._max_data_tokens: int = int(secrets.get("GRAPHRAG_MAX_DATA_TOKENS", 8000))
        self._map_max_tokens: int = int(secrets.get("GRAPHRAG_MAP_MAX_TOKENS", 700))
        self._reduce_max_tokens: int = int(secrets.get("GRAPHRAG_REDUCE_MAX_TOKENS", 1200))
        self._allow_general_knowledge: bool = str(secrets.get("GRAPHRAG_ALLOW_GENERAL_KNOWLEDGE", "false")).lower() == "true"
        # crude char-based budget approximation (safe margin)
        self._approx_chars_per_token: int = 4
        self._chunk_chars: int = int(secrets.get("GRAPHRAG_MAP_CHUNK_CHARS", 1800))
        self._initialize_search_clients()
        self._initialize_openai()
    
    def _initialize_search_clients(self) -> None:
        """Initialize Azure AI Search clients for each index."""
        try:
            endpoint = "https://chat-search.search.windows.net"
            api_key = self.secrets["AZURE_SEARCH_KEY"]
            credential = AzureKeyCredential(api_key)
            
            # Initialize search clients for each GraphRAG index
            self._search_clients = {
                "community": SearchClient(
                    endpoint=endpoint,
                    index_name="graphrag-community-full_content",
                    credential=credential
                ),
                "entity": SearchClient(
                    endpoint=endpoint,
                    index_name="graphrag-entity-description",
                    credential=credential
                ),
                "text_unit": SearchClient(
                    endpoint=endpoint,
                    index_name="graphrag-text_unit-text",
                    credential=credential
                )
            }
            
            log_to_azure("GraphRAG service initialized successfully with Azure AI Search clients")
            
        except Exception as e:
            log_to_azure(f"Error initializing GraphRAG service: {e}")
            self._search_clients = {}

    def _initialize_openai(self) -> None:
        """Initialize Azure OpenAI client for map-reduce orchestration."""
        try:
            self._openai_client = openai.AzureOpenAI(
                azure_endpoint=self.secrets["AZURE_OPENAI_ENDPOINT"],
                api_key=self.secrets["AZURE_OPENAI_API_KEY"],
                api_version="2024-05-01-preview",
            )
            log_to_azure("GraphRAG OpenAI client initialized")
        except Exception as e:
            log_to_azure(f"Error initializing OpenAI client: {e}")
            self._openai_client = None

    # ---------- Orchestrated Query Flows (Global / Local / DRIFT) ----------

    def _chat(self, messages: list[dict], max_tokens: int = 1200, temperature: float = 0.1) -> str:
        if not self._openai_client:
            raise RuntimeError("OpenAI client not initialized")
        completion = self._openai_client.chat.completions.create(
            model=self.secrets.get("AZURE_OPENAI_4O_DEPLOYMENT_ID", "gpt-4o"),
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
        )
        return completion.choices[0].message.content or ""

    def _truncate(self, text: str, max_chars: int = 6000) -> str:
        return text if len(text) <= max_chars else text[:max_chars] + "..."

    def _chunk_text(self, text: str, chunk_size: int) -> list[str]:
        if not text:
            return []
        chunks: list[str] = []
        start = 0
        n = len(text)
        while start < n:
            end = min(start + chunk_size, n)
            chunks.append(text[start:end])
            start = end
        return chunks

    def _extract_json_array(self, raw: str) -> list[dict]:
        """Best-effort extraction of a JSON array from model output.
        - Tries direct json.loads
        - Then extracts the first [...] block and parses
        - Falls back to parsing simple '- point (rating: N)' bullet lists
        Returns a list[dict] with {'point': str, 'rating': int} items.
        """
        try:
            parsed = json.loads(raw)
            if isinstance(parsed, list):
                return [item for item in parsed if isinstance(item, dict)]
        except Exception:
            pass

        # Extract first JSON array block
        try:
            start = raw.find('[')
            end = raw.rfind(']')
            if start != -1 and end != -1 and end > start:
                block = raw[start:end + 1]
                parsed = json.loads(block)
                if isinstance(parsed, list):
                    return [item for item in parsed if isinstance(item, dict)]
        except Exception:
            pass

        # Fallback: bullet list heuristic
        items: list[dict] = []
        for line in raw.splitlines():
            t = line.strip().lstrip('-').strip()
            if not t:
                continue
            # try to find rating pattern '(rating: N)' or '[N/5]'
            rating: int | None = None
            if '(rating:' in t:
                try:
                    frag = t.split('(rating:')[1]
                    rating = int(''.join(ch for ch in frag if ch.isdigit()))
                except Exception:
                    rating = None
            if rating is None and '[' in t and '/5]' in t:
                try:
                    frag = t[t.find('[') + 1: t.find('/5]')]
                    rating = int(''.join(ch for ch in frag if ch.isdigit()))
                except Exception:
                    rating = None
            if rating is None:
                rating = 3
            point_text = t
            items.append({'point': point_text, 'rating': rating})
        return items

    def _map_prompt(self, user_question: str, report_title: str, report_chunk: str) -> list[dict]:
        system = (
            "You are performing the MAP stage of GraphRAG global search. "
            "From the provided community report CHUNK, extract 3-6 key points as JSON, each with: "
            "{'point': <fact grounded in text>, 'rating': <1-5 importance>} strictly from the chunk. "
            "Do not add commentary; output only a JSON array."
        )
        user = (
            f"User question:\n{user_question}\n\n"
            f"Report title: {report_title}\n"
            f"Report chunk:\n{report_chunk}"
        )
        return [{"role": "system", "content": system}, {"role": "user", "content": user}]

    def _reduce_prompt(self, user_question: str, top_points: list[str]) -> list[dict]:
        general_knowledge_instruction = (
            " You may incorporate relevant general knowledge cautiously when it helps connect the provided points."
            if self._allow_general_knowledge else ""
        )
        system = (
            "You are performing the REDUCE stage of GraphRAG global search. "
            "Compose a well-structured, multi-paragraph answer using ONLY the provided points as grounding." 
            + general_knowledge_instruction
        )
        bullet_points = "\n- ".join([p for p in top_points if p])
        user = f"User question:\n{user_question}\n\nImportant points (ranked):\n- {bullet_points}"
        return [{"role": "system", "content": system}, {"role": "user", "content": user}]

    def global_orchestrated(self, prompt: str, max_results: int = 5) -> list[GraphRAGQueryResult]:
        """Global search per GraphRAG: rated map over chunked community reports, then reduce."""
        if not self._search_clients:
            return []
        try:
            community_client = self._search_clients.get("community")
            if not community_client:
                return []

            # Fetch top community reports (grab extra to allow ranking/filtering)
            raw = community_client.search(search_text=prompt, top=max_results * 3, include_total_count=False)
            reports: list[dict] = []
            for r in raw:
                reports.append({
                    "title": r.get("title") or r.get("id") or "Community Report",
                    "content": r.get("text") or r.get("full_content") or r.get("summary") or r.get("content") or "",
                    "rank": r.get("rank"),
                    "source_url": r.get("source_url") or r.get("url"),
                    "document_id": r.get("document_id") or r.get("id"),
                    "filepath": r.get("filepath") or r.get("path")
                })

            if not reports:
                return []

            # MAP over chunked reports to collect rated points
            # Token budget guard (approximate): stop when collected data exceeds budget
            approx_budget_chars = self._max_data_tokens * self._approx_chars_per_token
            consumed_chars = 0
            collected_points: list[tuple[int, str, dict]] = []  # (rating, point, rep_meta)

            for rep in reports:
                if consumed_chars >= approx_budget_chars:
                    break
                content = rep.get("content", "")
                chunks = self._chunk_text(content, self._chunk_chars)
                for chunk in chunks:
                    if consumed_chars >= approx_budget_chars:
                        break
                    consumed_chars += len(chunk)
                    messages = self._map_prompt(prompt, rep["title"], chunk)
                    try:
                        map_json = self._chat(messages, max_tokens=self._map_max_tokens, temperature=0.0)
                        # Expect JSON array of {point, rating}; use robust extractor
                        parsed_items = self._extract_json_array(map_json)
                        for item in parsed_items:
                            point = (item or {}).get("point")
                            rating_val = (item or {}).get("rating")
                            try:
                                rating = int(rating_val)
                            except Exception:
                                rating = 0
                            if point and 1 <= rating <= 5:
                                collected_points.append((rating, str(point), rep))
                    except Exception as e:
                        log_to_azure(f"Global map error: {e}")

            # Rank and filter collected points across chunks/reports
            collected_points.sort(key=lambda x: x[0], reverse=True)
            top_points_only = [p for _, p, _ in collected_points[: max_results * 6]]

            # REDUCE to final answer
            reduced = ""
            if top_points_only:
                try:
                    reduced = self._chat(self._reduce_prompt(prompt, top_points_only), max_tokens=self._reduce_max_tokens, temperature=0.0)
                except Exception as e:
                    log_to_azure(f"Global reduce error: {e}")

            # Return results (mapped + reduced at top)
            results: list[GraphRAGQueryResult] = []
            if reduced:
                results.append(GraphRAGQueryResult(
                    content=reduced,
                    source="global_reduce",
                    metadata={}
                ))
            # Also return a few high-rated points as supporting nuggets
            for idx, (rating, point, meta) in enumerate(collected_points[: max_results], 1):
                results.append(GraphRAGQueryResult(
                    content=f"[{rating}/5] {point}",
                    source=f"global_map_point_{idx}",
                    metadata={
                        "case_number": meta.get("document_id"),
                        "case_name": meta.get("title"),
                        "source_url": meta.get("source_url"),
                        "filepath": meta.get("filepath"),
                        "document_id": meta.get("document_id"),
                    }
                ))
           
            return results
        except Exception as e:
            log_to_azure(f"Global orchestrated error: {e}")
            return []

    def local_orchestrated(self, prompt: str, max_results: int = 5) -> list[GraphRAGQueryResult]:
        """Local search: entity-first retrieval then expand into text units."""
        if not self._search_clients:
            return []
        try:
            entity_client = self._search_clients.get("entity")
            text_client = self._search_clients.get("text_unit")
            community_client = self._search_clients.get("community")
            if not entity_client or not text_client:
                return []

            # Retrieve entities relevant to the prompt
            entities = list(entity_client.search(search_text=prompt, top=max_results, include_total_count=False))
            if not entities:
                return []

            # For each entity, fetch supporting text units
            combined_summaries: list[GraphRAGQueryResult] = []
            for i, ent in enumerate(entities, 1):
                ent_name = ent.get("name") or ent.get("entity") or ent.get("title") or "entity"
                ent_desc = ent.get("text") or ent.get("description") or ent.get("content") or ""
                community_id = ent.get("community") or ent.get("cluster")

                # Pull text units mentioning this entity
                text_hits = list(text_client.search(search_text=ent_name, top=3, include_total_count=False))
                snippets = []
                for th in text_hits:
                    snippet = th.get("text") or th.get("content") or th.get("summary") or ""
                    snippets.append(self._truncate(snippet, 1200))

                # Optionally include a bit of community report context related to the entity
                cr_snippets: list[str] = []
                if community_client and community_id is not None:
                    try:
                        crs = list(community_client.search(search_text=str(community_id), top=1, include_total_count=False))
                    except Exception:
                        crs = []
                    for cr in crs:
                        cr_snippets.append(self._truncate(cr.get("text") or cr.get("full_content") or cr.get("summary") or cr.get("content") or "", 600))

                # Ask LLM to synthesize for this entity
                messages = [
                    {"role": "system", "content": "You are performing LOCAL GraphRAG synthesis for a specific entity."},
                    {"role": "user", "content": (
                        f"Question:\n{prompt}\n\nEntity: {ent_name}\n"
                        f"Entity description:\n{self._truncate(ent_desc, 1200)}\n\n"
                        f"Supporting text units:\n- " + "\n- ".join(snippets) + ("\n\nCommunity context:\n- " + "\n- ".join(cr_snippets) if cr_snippets else "")
                    )}
                ]
                try:
                    synthesis = self._chat(messages, max_tokens=700, temperature=0.0)
                except Exception as e:
                    log_to_azure(f"Local synthesis error: {e}")
                    synthesis = ""

                combined_summaries.append(GraphRAGQueryResult(
                    content=synthesis or ent_desc,
                    source=f"local_entity_{i}",
                    metadata={
                        "entity": ent_name,
                        "source_url": ent.get("source_url") or ent.get("url"),
                        "document_id": ent.get("document_id") or ent.get("id"),
                        "filepath": ent.get("filepath") or ent.get("path"),
                    }
                ))
           
            return combined_summaries
        except Exception as e:
            log_to_azure(f"Local orchestrated error: {e}")
            return []

    def drift_orchestrated(self, prompt: str, max_results: int = 4) -> list[GraphRAGQueryResult]:
        """DRIFT search: entity + community context walk."""
        if not self._search_clients:
            return []
        try:
            entity_client = self._search_clients.get("entity")
            community_client = self._search_clients.get("community")
            text_client = self._search_clients.get("text_unit")
            if not entity_client or not community_client or not text_client:
                return []

            entities = list(entity_client.search(search_text=prompt, top=max_results, include_total_count=False))
            if not entities:
                return []

            results: list[GraphRAGQueryResult] = []
            for i, ent in enumerate(entities, 1):
                ent_name = ent.get("name") or ent.get("entity") or ent.get("title") or "entity"
                community_id = ent.get("community") or ent.get("cluster")

                # Pull nearby community reports
                community_reports = []
                if community_id is not None:
                    # Search by community id if the field is indexed, otherwise fallback to prompt
                    try:
                        community_reports = list(community_client.search(search_text=str(community_id), top=2, include_total_count=False))
                    except Exception:
                        community_reports = list(community_client.search(search_text=prompt, top=2, include_total_count=False))

                # Pull some text units for the entity
                text_hits = list(text_client.search(search_text=ent_name, top=2, include_total_count=False))

                cr_snippets = []
                for cr in community_reports:
                    cr_snippets.append(self._truncate(cr.get("text") or cr.get("full_content") or cr.get("summary") or cr.get("content") or "", 1000))
                tu_snippets = []
                for th in text_hits:
                    tu_snippets.append(self._truncate(th.get("text") or th.get("content") or th.get("summary") or "", 800))

                # DRIFT primer: generate initial broad answer and 1-2 follow-up questions
                primer_messages = [
                    {"role": "system", "content": "You are performing DRIFT GraphRAG primer (broad initial answer + follow-ups)."},
                    {"role": "user", "content": (
                        f"Question:\n{prompt}\n\nTop community insights:\n- " + "\n- ".join(cr_snippets[:2])
                    )}
                ]
                followups = []
                primer = ""
                try:
                    primer = self._chat(primer_messages, max_tokens=300, temperature=0.0)
                    # simple heuristic: extract lines ending with '?' as follow-ups (up to 2)
                    for line in (primer.splitlines() if primer else []):
                        if line.strip().endswith("?"):
                            followups.append(line.strip())
                            if len(followups) >= 2:
                                break
                except Exception as e:
                    log_to_azure(f"DRIFT primer error: {e}")

                # Synthesize DRIFT answer per entity context
                messages = [
                    {"role": "system", "content": "You are performing DRIFT GraphRAG synthesis (entity + community context)."},
                    {"role": "user", "content": (
                        f"Question:\n{prompt}\n\nEntity: {ent_name}\n\n"
                        f"Community context:\n- " + "\n- ".join(cr_snippets) + "\n\n"
                        f"Related text units:\n- " + "\n- ".join(tu_snippets) + ("\n\nFollow-up focus:\n- " + "\n- ".join(followups) if followups else "")
                    )}
                ]
                try:
                    drift_text = self._chat(messages, max_tokens=700, temperature=0.0)
                except Exception as e:
                    log_to_azure(f"DRIFT synthesis error: {e}")
                    drift_text = ""

                results.append(GraphRAGQueryResult(
                    content=drift_text or ("\n".join(cr_snippets + tu_snippets)[:700]),
                    source=f"drift_entity_{i}",
                    metadata={
                        "entity": ent_name,
                        "community": community_id,
                        "followups": followups,
                        "source_url": ent.get("source_url") or ent.get("url"),
                        "document_id": ent.get("document_id") or ent.get("id"),
                    }
                ))
          

            return results
        except Exception as e:
            log_to_azure(f"DRIFT orchestrated error: {e}")
            return []
    
    def query(self, prompt: str, query_type: str = "global", max_results: int = 5) -> List[GraphRAGQueryResult]:
        """Run orchestrated GraphRAG flows by default (global/local/drift)."""
        if query_type == "global":
            return self.global_orchestrated(prompt, max_results)
        if query_type == "local":
            return self.local_orchestrated(prompt, max_results)
        if query_type == "drift":
            return self.drift_orchestrated(prompt, max_results)
        # basic: fall back to plain text-unit search for simplicity
        try:
            text_client = self._search_clients.get("text_unit")
            if not text_client:
                return []
            raw = text_client.search(search_text=prompt, top=max_results, include_total_count=False)
            results: list[GraphRAGQueryResult] = []
            for i, r in enumerate(raw):
                content = r.get("text") or r.get("content") or r.get("summary") or str(r)
                results.append(GraphRAGQueryResult(
                    content=content,
                    source=f"basic_{i}",
                    metadata={
                        "source_url": r.get("source_url") or r.get("url"),
                        "document_id": r.get("document_id") or r.get("id"),
                        "filepath": r.get("filepath") or r.get("path"),
                    }
                ))
            return results
        except Exception as e:
            log_to_azure(f"Basic search error: {e}")
            return []
    
    def query_all_modes(self, prompt: str, max_results: int = 3) -> Dict[str, List[GraphRAGQueryResult]]:
        """
        Query using all available modes and return combined results.
        
        Args:
            prompt (str): The query prompt
            max_results (int): Maximum number of results per mode
            
        Returns:
            Dict[str, List[GraphRAGQueryResult]]: Results organized by query mode
        """
        all_results = {}
        
        for query_type in ["global", "local", "drift", "basic"]:
            try:
                results = self.query(prompt, query_type, max_results)
                all_results[query_type] = results
            except Exception as e:
                log_to_azure(f"Error in {query_type} query: {e}")
                all_results[query_type] = []
        
        return all_results
    
    def is_available(self) -> bool:
        """Check if the GraphRAG service is available."""
        return len(self._search_clients) > 0

👉 Any guidance on what might be causing this (wrong embeddings, chunking setup, or something else in my workflow) would be greatly appreciated.

Thanks in advance!

[natoverse]

Have a look at the inputs docs for some tips on getting metadata such as the title repeated in your chunks. This generally helps quite a bit with answer quality. https://microsoft.github.io/graphrag/index/inputs/

[benifbond]

Thanks a lot, kinda wondering if my azure_ai_search implementation is what it should be?

[tummalapallimurali]

Hi , I had this same question. does ai search support graph rag. there is no documentation.