Refactor LLM service and analysis logic for improved structure and error handling

- Updated `llm_service.py` to streamline LLM calls and response handling.
- Enhanced `analyse_service.py` with Pydantic models for structured analysis results.
- Improved JSON parsing in `_parse_analysis_response` to handle various response formats.
- Refined prompt templates in `prompt_templates.py` for better clarity and structure.
- Modified `generation_service.py` to support direct job description input for cover letter generation.
- Added test cases in service modules to validate functionality and ensure robustness.
- Updated documentation in `spec.md` to reflect changes in service architecture and functionality.

docs/spec.md

@@ -46,50 +46,66 @@ apply-helper/
 
 ### 2.2 LLM 集成层
 
-#### `src/services/llm_service.py` — 核心LLM交互逻辑
-- **核心功能**: 封装所有LLM调用，处理JSON解析和错误处理
+#### `src/services/llm_service.py` — LLM服务包装层
+- **核心功能**: 提供LLM调用的统一接口，负责提示词模板格式化和LiteLLM调用
 - **主要函数**:
-  - `analyse_llm(jd: str, user_info: str) -> Dict[str, Any]`: 工作分析，返回结构化JSON
-  - `refine_llm(summary: Dict, feedback: str) -> Dict[str, Any]`: 基于反馈优化分析
-  - `generate_resume_llm(summary: Dict, user_info: str) -> str`: 生成Markdown格式简历
-  - `generate_cover_letter_llm(summary: Dict, user_info: str) -> str`: 生成纯文本求职信
-  - `_parse_json_response(response: str) -> Dict`: 解析LLM返回的JSON（处理代码块包装）
-
-#### `src/llm/litellm_client.py` — Azure OpenAI集成
-- **当前实现**: 仅支持Azure OpenAI（尽管配置支持多provider）
-- **自动配置**: 基于环境变量自动检测和配置Azure客户端
+  - `analyse_llm(jd: str, user_info: str) -> str`: 工作分析，返回原始LLM响应字符串
+  - `refine_llm(summary_json: str, feedback: str) -> str`: 基于反馈优化分析，返回原始LLM响应
+  - `generate_resume_llm(summary_json: str, user_info: str) -> str`: 生成Markdown格式简历
+  - `generate_cover_letter_llm(job_description: str, user_info: str) -> str`: 生成德语求职信
+
+#### `src/llm/litellm_client.py` — LiteLLM客户端集成
+- **多Provider支持**: 优先支持Azure OpenAI，备用支持标准OpenAI
+- **自动配置**: 基于环境变量自动检测和配置最优客户端
 - **主要函数**:
   - `call_llm(prompt: str, model: str = None, max_tokens: int = 800, temperature: float = 1.0) -> str`
-  - `get_azure_client() -> Any`: 配置Azure OpenAI客户端
-  - 包含连接测试和调试模式
+  - `get_azure_client() -> dict`: 配置Azure OpenAI客户端
+  - `get_openai_client() -> dict`: 配置标准OpenAI客户端
+  - 包含连接测试和调试模式，支持litellm debug
 
 #### `src/llm/prompt_templates.py` — 提示词模板管理
 - **模板类型**: analyse, refine, generate_resume, generate_cover_letter
 - **函数**: `get_template(name: str) -> str`
-- **特点**: 字典存储，包含详细的JSON输出格式要求
+- **特点**: 
+  - 字典存储，包含详细的JSON输出格式要求
+  - ANALYSE_PROMPT: 德国科技市场专家角色，8-12个技能提取，4-6个匹配点分析
+  - GENERATE_COVER_LETTER_PROMPT: 德语商务求职信生成，符合德国商务信函规范
+  - 所有模板包含明确的输出格式要求和角色设定
 
 #### 核心处理逻辑
-- **JSON响应解析**: 自动处理LLM返回的```json代码块包装格式
-- **提示词管理**: 从模板获取提示词，动态替换参数
-- **错误处理**: 捕获JSON解析错误和API调用异常
-- **多任务协调**: 分析→生成→返回结果的完整流程
+- **提示词管理**: 从模板获取提示词，使用Python字符串format动态替换参数
+- **LLM调用**: 通过LiteLLM统一接口调用不同provider的模型
+- **错误处理**: LiteLLM层处理API调用异常，服务层处理业务逻辑异常
+- **响应处理**: 返回原始字符串响应，由上层服务负责结构化解析
 
 
 ### 2.3 业务服务层
 
 #### `src/services/analyse_service.py` — 分析服务
-- **功能**: 职位描述与用户背景的匹配分析
+- **功能**: 职位描述与用户背景的匹配分析，使用Pydantic数据模型
+- **数据模型**: `AnalysisResult(BaseModel)` - 结构化分析结果
+  - key_skills: List[str] - 关键技能列表
+  - match_points: List[str] - 匹配优势点
+  - gap_points: List[str] - 技能差距点
+  - suggestions: List[str] - 改进建议
+  - pitch: str - 价值主张
 - **主要逻辑**: 
   - 验证输入参数非空
   - 委托LLM服务进行分析
-  - analyse() - 初始分析
-  - refine() - 基于反馈优化分析
+  - `_parse_analysis_response()` - 复杂JSON解析逻辑，处理代码块包装
+  - `analyse()` - 初始分析，返回AnalysisResult对象
+  - `refine()` - 基于反馈优化分析，使用model_dump_json()序列化
 
 #### `src/services/generation_service.py` — 文档生成服务
 - **功能**: 编排简历和求职信的生成
+- **主要接口**:
+  - `generate_resume(summary: AnalysisResult, user_info: str) -> str` - 生成简历
+  - `generate_cover_letter(job_description: str, user_info: str) -> str` - 生成求职信
+  - `generate_both(summary: AnalysisResult, user_info: str, job_description: str) -> Tuple[str, str]` - 生成完整文档对
 - **主要逻辑**:
-  - 基于分析结果生成文档
-  - 并行调用LLM服务生成简历(Markdown)和求职信(文本)
+  - 使用AnalysisResult对象和原始文本作为输入
+  - 调用LLM服务生成简历(Markdown)和求职信(德语文本)
+  - 支持动态导入处理，兼容模块和独立运行
   - 返回生成的文档元组
 
 ### 2.4 模拟数据系统
@@ -164,11 +180,17 @@ apply-helper/
 
 ### 4.2 LLM集成配置
 
-**当前实现**: 仅支持Azure OpenAI
+**多Provider支持**: 优先Azure OpenAI，备用标准OpenAI
 
-**必需配置**: AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_MODEL, AZURE_OPENAI_API_VERSION
+**Azure OpenAI配置**: AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_MODEL, AZURE_OPENAI_API_VERSION(默认2024-12-01-preview)
 
-**配置逻辑**: 自动检测Azure配置，无配置时报错，不支持其他provider
+**OpenAI配置**: OPENAI_API_KEY（使用gpt-3.5-turbo模型）
+
+**配置逻辑**: 
+- 优先检测Azure配置，如果完整则使用Azure
+- Azure不可用时回退到标准OpenAI
+- 支持模型参数覆盖，但仅支持azure/前缀的模型
+- 包含详细的配置验证和错误提示
 
 ### 4.3 开发和测试
 
@@ -177,9 +199,11 @@ apply-helper/
 - `src/mock_data.py` 包含完整测试数据集
 - 点击"Mock Analyse"按钮即可加载预设结果
 
-**调试模式**:
-- `src/llm/litellm_client.py` 包含连接测试代码
-- 运行 `python src/llm/litellm_client.py` 测试LLM连接
+**调试和测试模式**:
+- `python src/llm/litellm_client.py` - 测试LLM连接和配置验证
+- `python src/services/analyse_service.py` - 测试分析服务完整流程
+- `python src/services/generation_service.py` - 测试文档生成流程
+- 包含litellm._turn_on_debug()调试支持
 
 ### 4.4 架构特点
 
@@ -189,7 +213,8 @@ apply-helper/
 - 服务层薄包装，便于替换实现
 
 **扩展点**:
-- 添加新的LLM provider: 修改 `litellm_client.py`
-- 添加PDF导出: 实现 `pdf_service.py`
-- 添加新的生成模板: 扩展 `prompt_templates.py`
-- 添加数据验证: 使用已配置的Pydantic
+- 添加新的LLM provider: 扩展 `litellm_client.py` 中的客户端配置函数
+- 添加PDF导出: 实现 `pdf_service.py` 集成WeasyPrint
+- 添加新的生成模板: 在 `prompt_templates.py` 中添加新模板常量
+- 数据验证增强: 当前使用Pydantic AnalysisResult模型，可扩展更多验证模型
+- 多语言支持: 扩展prompt_templates支持不同语言的求职信生成

src/README.md

@@ -69,4 +69,8 @@ apply-helper/
 │   └── prompt_templates.py
 ├── exports/                 # Directory for exported PDF files
 └── tests/                   # Unit tests
-```
+```
+
+
+PYTHONPATH=src python -m services.analyse_service
+

src/llm/litellm_client.py

@@ -92,7 +92,7 @@ def call_llm(prompt: str, model: Optional[str] = None, max_tokens: int = 800, te
         
     except Exception as e:
         print(f"An error occurred while calling the LLM: {e}")
-        raise
+        raise e  # Re-raise the original exception
 
 
 if __name__ == "__main__":

src/llm/prompt_templates.py

@@ -2,27 +2,66 @@
 Manages all prompt templates for the application.
 """
 
-PROMPT_TEMPLATES = {
-    "analyse": """
-You are a professional career coach. Analyze the provided Job Description (JD) and User Information.
-Your goal is to extract key skills, identify matches and gaps, and provide actionable suggestions.
+ANALYSE_PROMPT = """
+You are an expert career strategist specializing in the German tech job market with deep understanding of software development roles and industry requirements.
+
+**Task:** Analyze the Job Description against the candidate's background to provide comprehensive career guidance.
 
 **Job Description:**
 {jd}
 
-**User Information:**
+**Candidate Information:**
 {user}
 
-**Your analysis should be in the following JSON format:**
+**Analysis Requirements:**
+
+1. **Key Skills Extraction** - Identify 8-12 critical technical and soft skills from the JD, prioritizing:
+   - Programming languages and frameworks specifically mentioned
+   - Cloud platforms and DevOps tools
+   - Development methodologies (Agile, TDD, etc.)
+   - Domain-specific requirements (e.g., scalability, testing)
+   - Soft skills (teamwork, communication, learning agility)
+
+2. **Match Analysis** - Identify 4-6 strong alignment points where candidate excels:
+   - Direct technology matches with concrete project examples
+   - Relevant experience depth and breadth
+   - Methodological alignment (Agile, CI/CD, etc.)
+   - Cultural fit indicators
+   - Language requirements fulfillment
+
+3. **Gap Analysis** - Identify 3-5 key areas for improvement:
+   - Missing or limited experience with required technologies
+   - Lack of specific domain knowledge
+   - Experience depth gaps (junior vs senior expectations)
+   - Certification or formal training gaps
+
+4. **Strategic Recommendations** - Provide 4-6 actionable, specific suggestions:
+   - Concrete learning paths for technology gaps
+   - Project ideas to demonstrate missing skills
+   - Networking or certification opportunities
+   - Interview preparation focus areas
+   - Portfolio enhancement recommendations
+
+5. **Value Proposition** - Craft a compelling 2-3 sentence pitch highlighting:
+   - Unique combination of candidate's strengths
+   - How their background solves company's specific needs
+   - Growth potential and learning agility
+
+**CRITICAL: Response must be valid JSON only. No additional text.**
+
+**Required JSON format:**
+```json
 {{
-    "key_skills": ["skill1", "skill2", ...],
-    "match_points": ["point1", "point2", ...],
-    "gap_points": ["point1", "point2", ...],
-    "suggestions": ["suggestion1", "suggestion2", ...],
-    "pitch": "A short, compelling pitch for the user."
+    "key_skills": ["skill1", "skill2", "skill3", "skill4", "skill5", "skill6", "skill7", "skill8"],
+    "match_points": ["point1", "point2", "point3", "point4"],
+    "gap_points": ["gap1", "gap2", "gap3"],
+    "suggestions": ["suggestion1", "suggestion2", "suggestion3", "suggestion4"],
+    "pitch": "Compelling 2-3 sentence value proposition for this specific role."
 }}
-""",
-    "refine": """
+```
+"""
+
+REFINE_PROMPT = """
 You are a professional career coach. A summary has been generated based on a Job Description and User Information.
 Now, refine this summary based on the user's feedback.
 
@@ -32,16 +71,21 @@ Now, refine this summary based on the user's feedback.
 **User Feedback:**
 {feedback}
 
+**IMPORTANT: Your response must be valid JSON only. Do not include any text before or after the JSON.**
+
 **Your refined analysis should be in the same JSON format as the original:**
+```json
 {{
-    "key_skills": ["skill1", "skill2", ...],
-    "match_points": ["point1", "point2", ...],
-    "gap_points": ["point1", "point2", ...],
-    "suggestions": ["suggestion1", "suggestion2", ...],
+    "key_skills": ["skill1", "skill2", "skill3"],
+    "match_points": ["point1", "point2", "point3"],
+    "gap_points": ["point1", "point2", "point3"],
+    "suggestions": ["suggestion1", "suggestion2", "suggestion3"],
     "pitch": "A short, compelling pitch for the user."
 }}
-""",
-    "generate_resume": """
+```
+"""
+
+GENERATE_RESUME_PROMPT = """
 You are a professional resume writer. Based on the following analysis and user information, generate a professional resume in Markdown format.
 The resume should be tailored to the job description implied in the analysis.
 
@@ -56,30 +100,64 @@ The resume should be tailored to the job description implied in the analysis.
 - Highlight the most relevant skills and experiences.
 - Use professional and action-oriented language.
 - Do not include any introductory text like "Here is the resume:".
-""",
-    "generate_cover_letter": """
-You are a professional cover letter writer. Based on the following analysis and user information, generate a compelling cover letter.
-The cover letter should be tailored to the job description implied in the analysis.
+"""
 
-**Analysis Summary:**
-{summary}
+GENERATE_COVER_LETTER_PROMPT = """
+You are an expert HR recruiter in the German IT job market.
 
-**User Information:**
+Generate a professional, tailored German Cover Letter (Anschreiben) for the given Job Description and Candidate CV. Follow these updated style rules:
+
+### Structure
+1. **Opening**
+   - 1–2 sentences only.
+   - First sentence: Mention the company/job role and express motivation.
+   - Second sentence: Short self-introduction (degree, focus, current status).
+
+2. **Main Section**
+   - Use **bullet points** (•) to highlight 3–5 most relevant skills and experiences from the CV, directly aligned with the Job Description.
+   - Each bullet point should be max. 2 lines, clear and specific.
+   - Where possible, mention concrete results/outcomes (STAR method).
+
+3. **Summary Paragraph**
+   - 1 short paragraph (2–3 sentences).
+   - Summarize why the candidate fits the role, combining motivation and competence.
+
+4. **Closing**
+   - Avoid overly flattering phrases.
+   - Clearly state availability (e.g., "Ab Oktober stehe ich Ihnen flexibel zur Verfügung.").
+   - Express interest in an interview in a confident, neutral tone (e.g., "Gerne erläutere ich Ihnen in einem persönlichen Gespräch, wie ich Ihr Team unterstützen kann.").
+   - End with: "Mit freundlichen Grüßen, [Name]"
+
+### Style Guidelines
+- Professional, concise, maximum 1 page.
+- Use active voice and confident tone.
+- Avoid generic filler sentences.
+- Balance between motivation and technical skills.
+- Output in proper German business letter style.
+
+### Inputs
+- Candidate CV:
 {user}
 
-**Instructions:**
-- The output must be plain text.
-- The tone should be professional and enthusiastic.
-- Address the key requirements from the job description.
-- Do not include any introductory text like "Here is the cover letter:".
+- Job Description:
+{jd}
+
+### Output
+- A complete Cover Letter (Anschreiben) in German, following the structure and style above.
 """
-}
 
 def get_template(name: str) -> str:
     """
     Retrieves a prompt template by name.
     """
-    template = PROMPT_TEMPLATES.get(name)
+    templates = {
+        "analyse": ANALYSE_PROMPT,
+        "refine": REFINE_PROMPT,
+        "generate_resume": GENERATE_RESUME_PROMPT,
+        "generate_cover_letter": GENERATE_COVER_LETTER_PROMPT
+    }
+    
+    template = templates.get(name)
     if not template:
         raise ValueError(f"Template '{name}' not found.")
     return template

src/services/analyse_service.py

@@ -1,18 +1,235 @@
-from typing import Dict, Any
+import json
+from typing import List
+from pydantic import BaseModel, Field
 from . import llm_service
 
-def analyse(jd: str, user_info: str) -> Dict[str, Any]:
+
+class AnalysisResult(BaseModel):
+    """Structured result from job description and user analysis."""
+    key_skills: List[str] = Field(description="Key skills required for the job")
+    match_points: List[str] = Field(description="Points where user matches job requirements")
+    gap_points: List[str] = Field(description="Areas where user lacks required skills")
+    suggestions: List[str] = Field(description="Actionable suggestions for improvement")
+    pitch: str = Field(description="A compelling pitch for the user")
+
+
+def _parse_analysis_response(response: str) -> AnalysisResult:
+    """
+    Parses a JSON string from the LLM response into AnalysisResult.
+    """
+    try:
+        # Remove code block markers if present
+        if "```json" in response:
+            start = response.find("```json") + 7
+            end = response.find("```", start)
+            if end != -1:
+                json_block = response[start:end].strip()
+            else:
+                json_block = response[start:].strip()
+        elif "```" in response and "{" in response:
+            # Handle cases where code blocks exist but without json marker
+            start = response.find("```") + 3
+            end = response.find("```", start)
+            if end != -1:
+                json_block = response[start:end].strip()
+            else:
+                json_block = response[start:].strip()
+        else:
+            # Find JSON object boundaries
+            start = response.find('{')
+            end = response.rfind('}') + 1
+            if start == -1 or end == 0:
+                raise ValueError("No JSON object found in response")
+            json_block = response[start:end]
+        
+        # Clean up the JSON block
+        json_block = json_block.strip()
+        
+        data = json.loads(json_block)
+        return AnalysisResult(**data)
+    except (json.JSONDecodeError, IndexError, ValueError) as e:
+        print(f"Failed to parse JSON response: {e}\nResponse was: {response[:500]}...")
+        raise ValueError("LLM response was not in the expected JSON format.")
+
+def analyse(jd: str, user_info: str) -> AnalysisResult:
     """
     Analyzes the job description and user information.
     """
     if not jd or not user_info:
         raise ValueError("Job Description and User Info cannot be empty.")
-    return llm_service.analyse_llm(jd, user_info)
+    response_text = llm_service.analyse_llm(jd, user_info)
+    return _parse_analysis_response(response_text)
 
-def refine(summary: Dict[str, Any], feedback: str) -> Dict[str, Any]:
+def refine(summary: AnalysisResult, feedback: str) -> AnalysisResult:
     """
     Refines the analysis based on user feedback.
     """
     if not summary or not feedback:
         raise ValueError("Summary and feedback cannot be empty.")
-    return llm_service.refine_llm(summary, feedback)
+    summary_json = summary.model_dump_json(indent=2)
+    response_text = llm_service.refine_llm(summary_json, feedback)
+    return _parse_analysis_response(response_text)
+
+
+if __name__ == "__main__":
+    # Test data
+    test_jd = """
+Seit 25 Jahren unterstützen wir bei inovex mit rund 500 IT-Expert:innen Unternehmen bei der Digitalisierung und Agilisierung ihres Kerngeschäfts an 8 Standorten deutschlandweit.
+
+Im Team Application Development entwickeln wir die verschiedensten Anwendungen, von skalierbaren Backends über performante Web Frontends bis hin zu modernen Apps, die teilweise von mehreren Millionen Menschen täglich benutzt werden. Unsere Konzepte implementieren wir bevorzugt mit Open Source Software im Rahmen agiler Projekte. Bei uns verläuft kein Projekt wie das andere – je nach Kunde, Team und Technologie-Stack ist jede Lösung einzigartig. 
+
+*Wir bei inovex mögen Vielfalt und Individualität. Deshalb freuen wir uns, wenn du unser Team noch bunter machst. 
+
+Was du bei uns bewegen kannst
+Gemeinsam mit deinem agilen Projektteam setzt du Projekte für Kunden unterschiedlicher Branchen um. Ihr seid cross-funktional aufgestellt und liefert alles aus einer Hand – von der Architektur über die Entwicklung bis zum DevOps-Betrieb. You build it, you run it.
+
+Dein Job beginnt nicht erst mit der Entwicklung von Software: Du unterstützt bei der Aufnahme und Analyse der Kundenanforderungen und stimmst dich eng mit deinem Team ab.
+
+Du fühlst dich gleichermaßen im Frontend wie im Backend zu Hause und bringst deine Erfahrung in beiden Bereichen ein – egal, ob es um Architekturen oder die Gestaltung von Single Page Applications geht.
+
+Du unterstützt deine Kolleg:innen mithilfe automatisierter Testing-Verfahren (Unit Testing, CI/CD, Ende-zu-Ende-Tests u. v. m.) und sorgst somit für eine kontinuierliche Qualitätskontrolle und -optimierung.
+
+ 
+
+In unseren Projekten verwenden wir häufig folgende Technologien:
+
+Kotlin, Java, Go, Python oder C#
+
+Angular, React, TypeScript, Vue.js., Next.js
+
+Docker, Gitlab
+
+AWS, GCP, Azure, Kubernetes
+
+Wer gut zu uns passen würde
+Ob du ein Studium oder eine Ausbildung im IT-Bereich abgeschlossen hast, ist für uns nebensächlich – für uns zählen deine fachlichen Skills und deine Persönlichkeit: 
+
+Du hast mehr als ein Jahr Berufserfahrung und fundierte Kenntnisse in mehreren der oben genannten Technologien. Idealerweise hast du bereits erste Berührungspunkte mit Cloud-Umgebungen gesammelt. 
+
+Du hast den Anspruch, dich in neue Technologien einzuarbeiten und sie in Bezug auf den Projekteinsatz zu prüfen. 
+
+Du beteiligst dich gerne an Code Reviews und setzt dich konstruktiv mit deiner Arbeit auseinander.
+
+Es ist dir wichtig, ein umfassendes Verständnis der Standpunkte deiner Team-Mitglieder und Kunden zu entwickeln.
+
+Sehr gute Deutschkenntnisse sind Voraussetzung (mind. Level C1), gute Englischkenntnisse runden dein Profil ab.  
+
+Ab Oktober freuen wir uns auf Verstärkung in unserem Team!
+
+Was wir dir bieten
+inovex Culture: Kommunikation auf Augenhöhe, flache Hierarchien, Arbeiten in selbstorganisierten und agilen Teams, Vertrauen und Offenheit, starker Zusammenhalt
+Level Up: Weiterbildungsbudget, eigene inovex Academy, Onboarding- und Mentoring-Programm, enger Austausch mit der Community
+Balance: Flexibles und mobiles Arbeiten, keine Kernarbeitszeiten, Workation, 30 Tage Urlaub
+Familienfreundlichkeit: Flexibles Arbeitszeitmodell, Zuschuss zur Kinderbetreuung, Überstunden nur im Ausnahmefall
+Individualität: Betriebliche Altersvorsorge, E-Gym Wellpass, inovex Sportgruppen/ Sport-Community
+Mobilität: JobRad, Firmenwagen-Leasing 
+    """
+    
+    test_user_info = """
+Start Hanbin Chen
+Master Informatik-Absolvent | LLM-Forscher | Full-Stack-Softwareentwickler
+Ausbildung
+RWTH Aachen University, Master | Informatik 2020.10 - 2025.07
+Masterarbeit: MedKGC (Medical Knowledge Graph Construction)
+• Entwicklung einer End-to-End-Pipeline für die medizinische Wissensextraktion aus Ra-
+diologieberichten mittels LLMs und deren Darstellung in Knowledge Graphs.
+• Implementierung von Named Entity Recognition mit GPT-4o und Llama3 unter Verwen-
+dung eines neuartigen RAG-Ansatzes und Integration von UMLS-Ontologien.
+• Durchführung von Few-Shot Prompting zur Bewertung der LLM-Leistung.
+Fachhochschule Hannover(HsH), Bachelor | Angewandte Informatik 2017.09 - 2020.09
+Berufsprofil
+Erfahrener Softwareentwickler
+spezialisiert auf skalierbare Agenten-
+basierte LLM-Anwendungen.
+Vertraut mit modernen KI-Tools
+und nutzt diese zur Steigerung
+von Produktivität und Qualität.
+Projekterfahrung
+Technische Fähigkeiten
+Programmiersprachen
+Python JavaScript Java
+Webtechnologien & Frameworks
+React Next.js TailwindCSS
+Backend & Frameworks
+RESTful API FASTapi Spring Boot
+Datenbank PostgreSQL MySQL
+ORM SQLAlchemy Hibernate
+Entwicklung & Project
+Agile Scrum TDD DDD
+KI & LLMs
+RAG Agent n8n Dify
+GitHub Copilot Cursor Claude Code
+DevOps & Cloud
+Docker CI/CD GitHub Actions
+AWS Vercel Supabase
+Sprachen
+• Full-Stack Entwickler | EmAilX - KI-gestützte E-Mail-Management SaaS (2025.07)
+– Aufbau einer Web Anwendung mit React, Next.js und TailwindCSS.
+– Integration von Azure OpenAI und Agent LLM für intelligente E-Mail-Erstellung.
+– Implementierung Unternehmens-Authentifizierung und Deployment auf Vercel.
+• Full-Stack-Entwickler | KI-verstärkte Scrum-Management-Plattform (2025.06)
+– Aufbau einer Full-Stack-Plattform mit React, Next.js und TailwindCSS.
+– Implementierung interaktiver Kanban-Boards und Chatbot-UI.
+– Aufbau eines LLM-Agent-Systems zur Anforderungsanalyse und automatischen
+Generierung von Projekt-Issues.
+• Full-Stack-Entwickler | AWS Hackathon (Top 25/1000+ auf Devpost) (2024.09–
+2024.10)
+– Aufbau eines Vue.js-Frontends und Gradio-Chatbots mit Amazon Bedrock und LLaMA
+3.1, ermöglicht RAG-basierte Teambildung und Spielereinblicke für VALORANT.
+– Leitung der Datenvorverarbeitung und des SQL-Agent-Designs.
+– Deployment der Full-Stack-App auf AWS EC2.
+• Android-Anwendungsentwickler | Should I Stay or Should I Go (2019.09 - 2020.09)
+– Entwicklung einer standortbasierten Anwendung mit MVVM-Architektur und Kotlin.
+– Anwendung der Test-Driven Development (TDD)-Methodik, mit Tests vor der Im-
+plementierung zur Gewährleistung der Codequalität.
+• Java-Desktop-Entwickler | Vier-Gewinnt-Spiel (2018.09 - 2019.05)
+– Implementierung eines Brettspiels in Java mit KI-Gegner (Minimax-Algorithmus).
+– Anwendung von TDD mit Unit-Tests für robuste Entwicklung und Codequalität.
+Studentische Tätigkeiten
+Deutsch (C1) Englisch (Fließend)
+Kontaktinformationen
+ +49 15732636211
+ [email protected]
+ HanbinChen97
+ Hanbin Chen
+ Persönliche Website
+• Full-Stack-Entwickler | MedAgent (RWTH Aachen University) (2024.03 -2025.07)
+– Architektur und Entwicklung des Frontends mit React und Next.js auf Basis einer
+modernen Architektur.
+– Implementierung eines RESTful-API-Backends mit Fokus auf Skalierbarkeit und
+Wartbarkeit.
+– Nutzung von CI/CD-Pipelines mit GitHub Actions und Docker.
+• Datenanalyst | KlimDim (ISAC GmbH) (2023.03 - 2023.12)
+– Entwicklung von Datenverarbeitungs-Pipelines und -visualisierung.
+– Nutzung von GitLab-Pipeline und Docker für Entwicklung und automatisierte Tests.
+    """
+    
+    try:
+        # Test analyse function
+        print("Testing analyse function...")
+        analysis_result = analyse(test_jd, test_user_info)
+        
+        print("Analysis Result:")
+        print("=" * 50)
+        print(f"key_skills: {analysis_result.key_skills}")
+        print(f"match_points: {analysis_result.match_points}")
+        print(f"gap_points: {analysis_result.gap_points}")
+        print(f"suggestions: {analysis_result.suggestions}")
+        print(f"pitch: {analysis_result.pitch}")
+        print("\n")
+        
+        # Test refine function
+        print("Testing refine function...")
+        test_feedback = "Please emphasize more on my Python skills and cloud experience"
+        
+        refined_result = refine(analysis_result, test_feedback)
+        print("Refined Result:")
+        print("=" * 50)
+        print(f"key_skills: {refined_result.key_skills}")
+        print(f"match_points: {refined_result.match_points}")
+        print(f"gap_points: {refined_result.gap_points}")
+        print(f"suggestions: {refined_result.suggestions}")
+        print(f"pitch: {refined_result.pitch}")
+            
+    except Exception as e:
+        print(f"Error during analysis: {e}")

src/services/generation_service.py

@@ -1,25 +1,37 @@
-from typing import Tuple, Dict, Any
-from . import llm_service
+from typing import Tuple
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
-def generate_resume(summary: Dict[str, Any], user_info: str) -> str:
+try:
+    from .analyse_service import AnalysisResult
+    from . import llm_service
+except ImportError:
+    from services.analyse_service import AnalysisResult
+    import services.llm_service as llm_service
+
+def generate_resume(summary: AnalysisResult, user_info: str) -> str:
     """
     Generates the resume (Markdown).
     """
     if not summary:
         raise ValueError("Analysis summary cannot be empty.")
 
-    return llm_service.generate_resume_llm(summary, user_info)
+    summary_json = summary.model_dump_json(indent=2)
+    return llm_service.generate_resume_llm(summary_json, user_info)
 
-def generate_cover_letter(summary: Dict[str, Any], user_info: str) -> str:
+def generate_cover_letter(job_description: str, user_info: str) -> str:
     """
-    Generates the cover letter (text).
+    Generates the cover letter (text) using direct text inputs.
     """
-    if not summary:
-        raise ValueError("Analysis summary cannot be empty.")
+    if not job_description:
+        raise ValueError("Job description cannot be empty.")
+    if not user_info:
+        raise ValueError("User info cannot be empty.")
 
-    return llm_service.generate_cover_letter_llm(summary, user_info)
+    return llm_service.generate_cover_letter_llm(job_description, user_info)
 
-def generate_both(summary: Dict[str, Any], user_info: str) -> Tuple[str, str]:
+def generate_both(summary: AnalysisResult, user_info: str, job_description: str) -> Tuple[str, str]:
     """
     Generates both the resume (Markdown) and cover letter (text).
     """
@@ -27,6 +39,157 @@ def generate_both(summary: Dict[str, Any], user_info: str) -> Tuple[str, str]:
         raise ValueError("Analysis summary cannot be empty.")
 
     resume_md = generate_resume(summary, user_info)
-    cover_letter_txt = generate_cover_letter(summary, user_info)
+    cover_letter_txt = generate_cover_letter(job_description, user_info)
 
     return resume_md, cover_letter_txt
+
+
+if __name__ == "__main__":
+    # Test data
+    test_summary = """
+    key_skills: ['Full-Stack Development', 'Frontend Technologies (React, Next.js, Vue.js, Angular, TypeScript)', 'Backend Development (Java, Kotlin, Go, Python, C#, Spring Boot, FASTAPI)', 'DevOps (Docker, CI/CD, Gitlab/GitHub Actions)', 'Cloud Platforms (AWS, GCP, Azure, Kubernetes)', 'Agile Methodologies (Scrum, TDD, DDD)', 'Automated Testing (Unit Testing, End-to-End, CI/CD)', 'RESTful APIs', 'Database Management (PostgreSQL, MySQL, ORM)', 'German (C1) & English language skills']
+    match_points: ['Mehrjährige Erfahrung in Full-Stack-Entwicklung mit Fokus auf Frontend (React, Next.js, Vue.js) und Backend (Java, Spring Boot, FASTAPI, Python-Systeme)', 'Nachgewiesene Cloud-Erfahrung (AWS, Vercel, Supabase) sowie Kenntnisse in DevOps und Deployment mit Docker, CI/CD und GitHub/GitLab Actions', 'Angewendete agile Methoden (Scrum, TDD, DDD) und umfassende Nutzung moderner Softwareentwicklungspraktiken', 'Fundierte Erfahrung im Bereich automatisiertes Testen (TDD, Unit-Tests) in mehreren Projekten', 'Sehr gute Deutschkenntnisse (C1) und fließendes Englisch']
+    gap_points: ['Kaum direkte Projekterfahrung mit Angular, TypeScript oder Vue.js als primärem Framework (nur kurz im AWS Hackathon erwähnt)', 'Wenig oder keine explizite Erfahrung mit Kotlin, Go oder C# in aktuellen Projekten (Kotlin vor allem für Android in einer älteren Tätigkeit)', 'Keine Nennung von GCP, Azure oder Kubernetes im Stack (lediglich AWS und Vercel/Supabase)', 'Wenig explizite Erfahrung im Bereich DevOps-Betrieb auf Gitlab (meist GitHub Actions, einmal GitLab-Pipeline)', 'Unit Test/End-to-End Testverfahren werden zwar erwähnt, aber Umfang und Tiefe könnten konkreter dargestellt werden']
+    suggestions: ['Vertiefe dein Praxiswissen in Angular, TypeScript und Vue.js durch kleinere Side-Projekte oder Online-Kurse, um gegenüber inovex als breiter aufgestellter Frontend-Experte aufzutreten.', 'Baue gezielt Kenntnisse in Kubernetes und, falls möglich, zumindest Grundkenntnisse in einem weiteren Cloud-Anbieter (z.B. GCP oder Azure) auf.', 'Arbeite aktiv an Projekten, bei denen die Implementierung und Wartung von Gitlab-basierten DevOps-Pipelines und Cloud-Betrieb gefordert ist.', 'Dokumentiere und präsentiere mehr Beispiele für die Anwendung von End-to-End-Tests und komplexerer Testautomatisierung in deinen letzten Projekten.', 'Sprich im Bewerbungsgespräch gezielt über deine Cross-Functionality und wie du dich zügig in neue Technologien (z.B. Go, C#) einarbeiten kannst.']
+    pitch: Hanbin Chen bringt als Master-Absolvent und erfahrener Full-Stack-Entwickler die perfekte Mischung aus fundierten Software-Engineering-Skills, Cloud-Expertise und Innovationsgeist mit. Seine Projekterfolge im Bereich LLMs, agiler Full-Stack-Entwicklung sowie CI/CD und Cloud-Deployment zeichnen ihn als modernen Teamplayer mit Wachstumspotenzial aus. Er ist bereit, seine Vielseitigkeit und Begeisterung für neue Technologien in Ihr cross-funktionales Team bei inovex einzubringen und weiter auszubauen.
+    """
+    
+    test_jd = """
+    Seit 25 Jahren unterstützen wir bei inovex mit rund 500 IT-Expert:innen Unternehmen bei der Digitalisierung und Agilisierung ihres Kerngeschäfts an 8 Standorten deutschlandweit.
+
+    Im Team Application Development entwickeln wir die verschiedensten Anwendungen, von skalierbaren Backends über performante Web Frontends bis hin zu modernen Apps, die teilweise von mehreren Millionen Menschen täglich benutzt werden. Unsere Konzepte implementieren wir bevorzugt mit Open Source Software im Rahmen agiler Projekte. Bei uns verläuft kein Projekt wie das andere – je nach Kunde, Team und Technologie-Stack ist jede Lösung einzigartig. 
+
+    *Wir bei inovex mögen Vielfalt und Individualität. Deshalb freuen wir uns, wenn du unser Team noch bunter machst. 
+
+    Was du bei uns bewegen kannst
+    Gemeinsam mit deinem agilen Projektteam setzt du Projekte für Kunden unterschiedlicher Branchen um. Ihr seid cross-funktional aufgestellt und liefert alles aus einer Hand – von der Architektur über die Entwicklung bis zum DevOps-Betrieb. You build it, you run it.
+
+    Dein Job beginnt nicht erst mit der Entwicklung von Software: Du unterstützt bei der Aufnahme und Analyse der Kundenanforderungen und stimmst dich eng mit deinem Team ab.
+
+    Du fühlst dich gleichermaßen im Frontend wie im Backend zu Hause und bringst deine Erfahrung in beiden Bereichen ein – egal, ob es um Architekturen oder die Gestaltung von Single Page Applications geht.
+
+    Du unterstützt deine Kolleg:innen mithilfe automatisierter Testing-Verfahren (Unit Testing, CI/CD, Ende-zu-Ende-Tests u. v. m.) und sorgst somit für eine kontinuierliche Qualitätskontrolle und -optimierung.
+
+    
+
+    In unseren Projekten verwenden wir häufig folgende Technologien:
+
+    Kotlin, Java, Go, Python oder C#
+
+    Angular, React, TypeScript, Vue.js., Next.js
+
+    Docker, Gitlab
+
+    AWS, GCP, Azure, Kubernetes
+
+    Wer gut zu uns passen würde
+    Ob du ein Studium oder eine Ausbildung im IT-Bereich abgeschlossen hast, ist für uns nebensächlich – für uns zählen deine fachlichen Skills und deine Persönlichkeit: 
+
+    Du hast mehr als ein Jahr Berufserfahrung und fundierte Kenntnisse in mehreren der oben genannten Technologien. Idealerweise hast du bereits erste Berührungspunkte mit Cloud-Umgebungen gesammelt. 
+
+    Du hast den Anspruch, dich in neue Technologien einzuarbeiten und sie in Bezug auf den Projekteinsatz zu prüfen. 
+
+    Du beteiligst dich gerne an Code Reviews und setzt dich konstruktiv mit deiner Arbeit auseinander.
+
+    Es ist dir wichtig, ein umfassendes Verständnis der Standpunkte deiner Team-Mitglieder und Kunden zu entwickeln.
+
+    Sehr gute Deutschkenntnisse sind Voraussetzung (mind. Level C1), gute Englischkenntnisse runden dein Profil ab.  
+
+    Ab Oktober freuen wir uns auf Verstärkung in unserem Team!
+
+    Was wir dir bieten
+    inovex Culture: Kommunikation auf Augenhöhe, flache Hierarchien, Arbeiten in selbstorganisierten und agilen Teams, Vertrauen und Offenheit, starker Zusammenhalt
+    Level Up: Weiterbildungsbudget, eigene inovex Academy, Onboarding- und Mentoring-Programm, enger Austausch mit der Community
+    Balance: Flexibles und mobiles Arbeiten, keine Kernarbeitszeiten, Workation, 30 Tage Urlaub
+    Familienfreundlichkeit: Flexibles Arbeitszeitmodell, Zuschuss zur Kinderbetreuung, Überstunden nur im Ausnahmefall
+    Individualität: Betriebliche Altersvorsorge, E-Gym Wellpass, inovex Sportgruppen/ Sport-Community
+    Mobilität: JobRad, Firmenwagen-Leasing 
+    """
+    
+    test_user_info = """
+    Start Hanbin Chen
+    Master Informatik-Absolvent | LLM-Forscher | Full-Stack-Softwareentwickler
+    Ausbildung
+    RWTH Aachen University, Master | Informatik 2020.10 - 2025.07
+    Masterarbeit: MedKGC (Medical Knowledge Graph Construction)
+    • Entwicklung einer End-to-End-Pipeline für die medizinische Wissensextraktion aus Ra-
+    diologieberichten mittels LLMs und deren Darstellung in Knowledge Graphs.
+    • Implementierung von Named Entity Recognition mit GPT-4o und Llama3 unter Verwen-
+    dung eines neuartigen RAG-Ansatzes und Integration von UMLS-Ontologien.
+    • Durchführung von Few-Shot Prompting zur Bewertung der LLM-Leistung.
+    Fachhochschule Hannover(HsH), Bachelor | Angewandte Informatik 2017.09 - 2020.09
+    Berufsprofil
+    Erfahrener Softwareentwickler
+    spezialisiert auf skalierbare Agenten-
+    basierte LLM-Anwendungen.
+    Vertraut mit modernen KI-Tools
+    und nutzt diese zur Steigerung
+    von Produktivität und Qualität.
+    Projekterfahrung
+    Technische Fähigkeiten
+    Programmiersprachen
+    Python JavaScript Java
+    Webtechnologien & Frameworks
+    React Next.js TailwindCSS
+    Backend & Frameworks
+    RESTful API FASTapi Spring Boot
+    Datenbank PostgreSQL MySQL
+    ORM SQLAlchemy Hibernate
+    Entwicklung & Project
+    Agile Scrum TDD DDD
+    KI & LLMs
+    RAG Agent n8n Dify
+    GitHub Copilot Cursor Claude Code
+    DevOps & Cloud
+    Docker CI/CD GitHub Actions
+    AWS Vercel Supabase
+    Sprachen
+    • Full-Stack Entwickler | EmAilX - KI-gestützte E-Mail-Management SaaS (2025.07)
+    – Aufbau einer Web Anwendung mit React, Next.js und TailwindCSS.
+    – Integration von Azure OpenAI und Agent LLM für intelligente E-Mail-Erstellung.
+    – Implementierung Unternehmens-Authentifizierung und Deployment auf Vercel.
+    • Full-Stack-Entwickler | KI-verstärkte Scrum-Management-Plattform (2025.06)
+    – Aufbau einer Full-Stack-Plattform mit React, Next.js und TailwindCSS.
+    – Implementierung interaktiver Kanban-Boards und Chatbot-UI.
+    – Aufbau eines LLM-Agent-Systems zur Anforderungsanalyse und automatischen
+    Generierung von Projekt-Issues.
+    • Full-Stack-Entwickler | AWS Hackathon (Top 25/1000+ auf Devpost) (2024.09–
+    2024.10)
+    – Aufbau eines Vue.js-Frontends und Gradio-Chatbots mit Amazon Bedrock und LLaMA
+    3.1, ermöglicht RAG-basierte Teambildung und Spielereinblicke für VALORANT.
+    – Leitung der Datenvorverarbeitung und des SQL-Agent-Designs.
+    – Deployment der Full-Stack-App auf AWS EC2.
+    • Android-Anwendungsentwickler | Should I Stay or Should I Go (2019.09 - 2020.09)
+    – Entwicklung einer standortbasierten Anwendung mit MVVM-Architektur und Kotlin.
+    – Anwendung der Test-Driven Development (TDD)-Methodik, mit Tests vor der Im-
+    plementierung zur Gewährleistung der Codequalität.
+    • Java-Desktop-Entwickler | Vier-Gewinnt-Spiel (2018.09 - 2019.05)
+    – Implementierung eines Brettspiels in Java mit KI-Gegner (Minimax-Algorithmus).
+    – Anwendung von TDD mit Unit-Tests für robuste Entwicklung und Codequalität.
+    Studentische Tätigkeiten
+    Deutsch (C1) Englisch (Fließend)
+    Kontaktinformationen
+     +49 15732636211
+     [email protected]
+     HanbinChen97
+     Hanbin Chen
+     Persönliche Website
+    • Full-Stack-Entwickler | MedAgent (RWTH Aachen University) (2024.03 -2025.07)
+    – Architektur und Entwicklung des Frontends mit React und Next.js auf Basis einer
+    modernen Architektur.
+    – Implementierung eines RESTful-API-Backends mit Fokus auf Skalierbarkeit und
+    Wartbarkeit.
+    – Nutzung von CI/CD-Pipelines mit GitHub Actions und Docker.
+    • Datenanalyst | KlimDim (ISAC GmbH) (2023.03 - 2023.12)
+    – Entwicklung von Datenverarbeitungs-Pipelines und -visualisierung.
+    – Nutzung von GitLab-Pipeline und Docker für Entwicklung und automatisierte Tests.
+    """
+   
+    
+    try:
+        cover_letter = generate_cover_letter(test_jd, test_user_info)
+        print("Generated Cover Letter:")
+        print("=" * 50)
+        print(cover_letter)
+    except Exception as e:
+        print(f"Error generating cover letter: {e}")

src/services/llm_service.py

@@ -1,54 +1,38 @@
-import json
-from typing import Tuple, Dict, Any
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
 from llm.litellm_client import call_llm
 from llm.prompt_templates import get_template
 
-def _parse_json_response(response: str) -> Dict[str, Any]:
-    """
-    Parses a JSON string from the LLM response.
-    """
-    try:
-        # The LLM might return a string enclosed in ```json ... ```, so we find the JSON block.
-        json_block = response[response.find('{'):response.rfind('}')+1]
-        return json.loads(json_block)
-    except (json.JSONDecodeError, IndexError) as e:
-        print(f"Failed to parse JSON response: {e}\nResponse was: {response}")
-        raise ValueError("LLM response was not in the expected JSON format.")
-
 
-def analyse_llm(jd: str, user_info: str) -> Dict[str, Any]:
+def analyse_llm(jd: str, user_info: str) -> str:
     """
     Calls the LLM to analyse the JD and user info.
     """
     prompt = get_template("analyse").format(jd=jd, user=user_info)
-    response_text = call_llm(prompt)
-    return _parse_json_response(response_text)
+    return call_llm(prompt)
 
 
-def refine_llm(summary: Dict[str, Any], feedback: str) -> Dict[str, Any]:
+def refine_llm(summary_json: str, feedback: str) -> str:
     """
     Calls the LLM to refine an existing analysis based on user feedback.
     """
-    summary_str = json.dumps(summary, indent=2)
-    prompt = get_template("refine").format(summary=summary_str, feedback=feedback)
-    response_text = call_llm(prompt)
-    return _parse_json_response(response_text)
+    prompt = get_template("refine").format(summary=summary_json, feedback=feedback)
+    return call_llm(prompt)
 
 
-def generate_resume_llm(summary: Dict[str, Any], user_info: str) -> str:
+def generate_resume_llm(summary_json: str, user_info: str) -> str:
     """
     Calls the LLM to generate a resume.
     """
-    summary_str = json.dumps(summary, indent=2)
-    prompt = get_template("generate_resume").format(summary=summary_str, user=user_info)
+    prompt = get_template("generate_resume").format(summary=summary_json, user=user_info)
     return call_llm(prompt)
 
 
-def generate_cover_letter_llm(summary: Dict[str, Any], user_info: str) -> str:
+def generate_cover_letter_llm(job_description: str, user_info: str) -> str:
     """
     Calls the LLM to generate a cover letter.
     """
-    summary_str = json.dumps(summary, indent=2)
-    prompt = get_template("generate_cover_letter").format(summary=summary_str, user=user_info)
+    prompt = get_template("generate_cover_letter").format(jd=job_description, user=user_info)
     return call_llm(prompt)