kunthawat/ALwrity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added blog writer implementation - WIP

Browse Source
This commit is contained in:
ajaysi
2025-09-12 10:26:08 +05:30
parent 1b65a9487b
commit c0a366269d
38 changed files with 4948 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
backend/services/llm_providers/__pycache__/gemini_provider.cpython-313.pyc
View File

Binary file not shown.

71
backend/services/llm_providers/gemini_grounded_provider.py
View File

@@ -43,7 +43,7 @@ class GeminiGroundedProvider:
# Initialize the Gemini client with timeout configuration
self.client = genai.Client(api_key=self.api_key)
self.timeout = 30 # 30 second timeout for API calls
self.timeout = 60 # 60 second timeout for API calls (increased for research)
logger.info("✅ Gemini Grounded Provider initialized with native Google Search grounding")
async def generate_grounded_content(
@@ -239,8 +239,8 @@ class GeminiGroundedProvider:
logger.info(f"Search queries: {grounding_metadata.web_search_queries}")
# Extract sources from grounding chunks
sources = [] # Initialize sources list
if hasattr(grounding_metadata, 'grounding_chunks') and grounding_metadata.grounding_chunks:
sources = []
for i, chunk in enumerate(grounding_metadata.grounding_chunks):
logger.info(f"Chunk {i} attributes: {dir(chunk)}")
if hasattr(chunk, 'web'):
@@ -251,15 +251,29 @@ class GeminiGroundedProvider:
'type': 'web'
}
sources.append(source)
result['sources'] = sources
logger.info(f"Extracted {len(sources)} sources")
logger.info(f"Extracted {len(sources)} sources from grounding chunks")
else:
logger.error("❌ CRITICAL: No grounding chunks found in response")
logger.error(f"Grounding metadata structure: {dir(grounding_metadata)}")
if hasattr(grounding_metadata, 'grounding_chunks'):
logger.error(f"Grounding chunks type: {type(grounding_metadata.grounding_chunks)}")
logger.error(f"Grounding chunks value: {grounding_metadata.grounding_chunks}")
raise ValueError("No grounding chunks found - grounding is not working properly")
logger.warning("⚠️ No grounding chunks found - this is normal for some queries")
logger.info(f"Grounding metadata available fields: {[attr for attr in dir(grounding_metadata) if not attr.startswith('_')]}")
# Check if we have search queries - this means Google Search was triggered
if hasattr(grounding_metadata, 'web_search_queries') and grounding_metadata.web_search_queries:
logger.info(f"✅ Google Search was triggered with {len(grounding_metadata.web_search_queries)} queries")
# Create sources based on search queries
for i, query in enumerate(grounding_metadata.web_search_queries[:5]): # Limit to 5 sources
source = {
'index': i,
'title': f"Search: {query}",
'url': f"https://www.google.com/search?q={query.replace(' ', '+')}",
'type': 'search_query',
'query': query
}
sources.append(source)
logger.info(f"Created {len(sources)} sources from search queries")
else:
logger.warning("⚠️ No search queries found either - grounding may not have been triggered")
result['sources'] = sources
# Extract citations from grounding supports
if hasattr(grounding_metadata, 'grounding_supports') and grounding_metadata.grounding_supports:
@@ -278,12 +292,37 @@ class GeminiGroundedProvider:
result['citations'] = citations
logger.info(f"Extracted {len(citations)} citations")
else:
logger.error("❌ CRITICAL: No grounding supports found in response")
logger.error(f"Grounding metadata structure: {dir(grounding_metadata)}")
if hasattr(grounding_metadata, 'grounding_supports'):
logger.error(f"Grounding supports type: {type(grounding_metadata.grounding_supports)}")
logger.error(f"Grounding supports value: {grounding_metadata.grounding_supports}")
raise ValueError("No grounding supports found - grounding is not working properly")
logger.warning("⚠️ No grounding supports found - this is normal when no web sources are retrieved")
# Create basic citations from the content if we have sources
if sources:
citations = []
for i, source in enumerate(sources[:3]): # Limit to 3 citations
citation = {
'type': 'reference',
'start_index': 0,
'end_index': 0,
'text': f"Source {i+1}",
'source_indices': [i],
'reference': f"Source {i+1}",
'source': source
}
citations.append(citation)
result['citations'] = citations
logger.info(f"Created {len(citations)} basic citations from sources")
else:
result['citations'] = []
logger.info("No citations created - no sources available")
# Extract search entry point for UI display
if hasattr(grounding_metadata, 'search_entry_point') and grounding_metadata.search_entry_point:
if hasattr(grounding_metadata.search_entry_point, 'rendered_content'):
result['search_widget'] = grounding_metadata.search_entry_point.rendered_content
logger.info("✅ Extracted search widget HTML for UI display")
# Extract search queries for reference
if hasattr(grounding_metadata, 'web_search_queries') and grounding_metadata.web_search_queries:
result['search_queries'] = grounding_metadata.web_search_queries
logger.info(f"✅ Extracted {len(grounding_metadata.web_search_queries)} search queries")
logger.info(f"✅ Successfully extracted {len(result['sources'])} sources and {len(result['citations'])} citations from grounding metadata")
logger.info(f"Sources: {result['sources']}")

34
backend/services/llm_providers/gemini_provider.py
View File

@@ -389,43 +389,13 @@ def gemini_structured_json_response(prompt, schema, temperature=0.7, top_p=0.9,
config=generation_config,
)
# Add debugging for response
logger.info("Gemini response | type=%s | has_text=%s | has_parsed=%s",
type(response), hasattr(response, 'text'), hasattr(response, 'parsed'))
if hasattr(response, 'text'):
logger.info(f"Gemini response.text: {repr(response.text)}")
if hasattr(response, 'parsed'):
logger.info(f"Gemini response.parsed: {repr(response.parsed)}")
# According to the documentation, we should use response.parsed for structured output
if hasattr(response, 'parsed') and response.parsed is not None:
logger.info("Using response.parsed for structured output")
return response.parsed
# Fallback to text if parsed is not available
if hasattr(response, 'text') and response.text:
logger.info("Falling back to response.text parsing")
text = response.text.strip()
# Strip markdown code fences if present
if text.startswith('```'):
if text.lower().startswith('```json'):
text = text[7:]
else:
text = text[3:]
if text.endswith('```'):
text = text[:-3]
text = text.strip()
try:
return json.loads(text)
except json.JSONDecodeError as e:
logger.error(f"Failed to parse response.text as JSON: {e}")
return {"error": f"Failed to parse JSON response: {e}", "raw_response": text[:500]}
logger.error("No valid response content found")
return {"error": "No valid response content found", "raw_response": ""}
logger.error("No valid structured response content found")
return {"error": "No valid structured response content found"}
except ValueError as e:
# API key related errors