pre-release milstone: generate full text letter

app.py

@@ -3,6 +3,7 @@ from config import CHEAP_API_BASE, CHEAP_API_KEY, CHEAP_MODEL
 from config import STRONG_API_BASE, STRONG_API_KEY, STRONG_MODEL
 from util import is_valid_url
 from util import mylogger
+from util import stream_together
 from taskNonAI import extract_url, file_to_html
 from taskAI import TaskAI
 ## load data
@@ -22,8 +23,7 @@ def init():
     os.system("shot-scraper install -b firefox")
     download_pandoc()
 
-
-def run_refine(api_base, api_key, api_model, jd_info, cv_file: str, cv_text):
+def prepare_input(jd_info, cv_file: str, cv_text):
     if jd_info:
         if is_valid_url(jd_info):
             jd = extract_url(jd_info)
@@ -42,11 +42,15 @@ def run_refine(api_base, api_key, api_model, jd_info, cv_file: str, cv_text):
             cv = file_to_html(cv_file)
     else:
         cv = mock_cv
+    return jd, cv
+
+def run_refine(api_base, api_key, api_model, jd_info, cv_text):
+    jd,cv=jd_info,cv_text
     cheapAPI = {"base": api_base, "key": api_key, "model": api_model}
     taskAI = TaskAI(cheapAPI, temperature=0.2, max_tokens=2048)  # max_tokens=2048
     info("API initialized")
     gen = (
-        taskAI.jd_preprocess(topic="job description", input=jd),
+        taskAI.jd_preprocess(input=jd),
         taskAI.cv_preprocess(input=cv),
     )
     info("tasks initialized")
@@ -67,32 +71,46 @@ def run_refine(api_base, api_key, api_model, jd_info, cv_file: str, cv_text):
 
 def run_compose(api_base, api_key, api_model, min_jd, min_cv):
     strongAPI = {"base": api_base, "key": api_key, "model": api_model}
-    taskAI = TaskAI(strongAPI, temperature=0.5, max_tokens=2048)
-    info("API initialized")
+    taskAI = TaskAI(strongAPI, temperature=0.6, max_tokens=4000)
+    info("Composing letter with CoT ...")
+    result = ""
+    for response in taskAI.compose_letter_CoT(jd=min_jd, resume=min_cv):
+        result += response.delta
+        yield result
 
+def finalize_letter_txt(api_base, api_key, api_model, debug_CoT, jd, cv):
+    cheapAPI = {"base": api_base, "key": api_key, "model": api_model}
+    taskAI = TaskAI(cheapAPI, temperature=0.2, max_tokens=2048)
+    info("Finalizing letter ...")
+    gen = stream_together(
+        taskAI.purify_letter(full_text=debug_CoT),
+        taskAI.get_jobapp_meta(JD=jd, CV=cv),
+    )
+    for result in gen:
+        yield result
 
 with gr.Blocks(
     title=DEMO_TITLE,
     theme=gr.themes.Base(primary_hue="blue", secondary_hue="sky", neutral_hue="slate"),
-) as demo:
+) as app:
     intro = f"""# {DEMO_TITLE}
     > You provide job description and résumé. I write Cover letter for you!
-    Before you use, please setup OpenAI-like API for 2 AI agents': Cheap AI and Strong AI.
+    Before you use, please fisrt setup API for 2 AI agents': Cheap AI and Strong AI.
     """
     gr.Markdown(intro)
 
     with gr.Row():
         with gr.Column(scale=1):
-            with gr.Accordion("AI setup (OpenAI-like API)", open=False):
+            with gr.Accordion("AI setup (OpenAI-compatible LLM API)", open=False):
                 gr.Markdown(
-                    "**Cheap AI**, an honest format converter and refinery machine, extracts essential info from job description and résumé, to reduce subsequent cost on Strong AI."
+                    "**Cheap AI**, an honest format converter and refiner, extracts essential info from job description and résumé, to reduce subsequent cost on Strong AI."
                 )
                 with gr.Group():
-                    weak_base = gr.Textbox(
+                    cheap_base = gr.Textbox(
                         value=CHEAP_API_BASE, label="API BASE"
                     )
-                    weak_key = gr.Textbox(value=CHEAP_API_KEY, label="API key")
-                    weak_model = gr.Textbox(value=CHEAP_MODEL, label="Model ID")
+                    cheap_key = gr.Textbox(value=CHEAP_API_KEY, label="API key")
+                    cheap_model = gr.Textbox(value=CHEAP_MODEL, label="Model ID")
                 gr.Markdown(
                     "---\n**Strong AI**, a thoughtful wordsmith, generates perfect cover letters to make both you and recruiters happy."
                 )
@@ -108,8 +126,9 @@ with gr.Blocks(
                 gr.Markdown("## Employer - Job Description")
                 jd_info = gr.Textbox(
                     label="Job Description",
-                    placeholder="Paste as Full Text (recommmend) or URL (may fail)",
+                    placeholder="Paste as Full Text (recommmend) or URL",
                     lines=5,
+                    max_lines=10,
                 )
             with gr.Group():
                 gr.Markdown("## Applicant - CV / Résumé")
@@ -126,10 +145,15 @@ with gr.Blocks(
                     )
         with gr.Column(scale=2):
             gr.Markdown("## Result")
-            with gr.Row():
-                min_jd = gr.TextArea(label="Minimized Job Description")
-                min_cv = gr.TextArea(label="Minimized CV / Résumé")
-            cover_letter_text = gr.TextArea(label="Cover Letter")
+            with gr.Accordion("Reformatting", open=True) as reformat_zone:
+                with gr.Row():
+                    min_jd = gr.TextArea(label="Reformatted Job Description")
+                    min_cv = gr.TextArea(label="Reformatted CV / Résumé")
+            with gr.Accordion("Expert Zone", open=False) as expert_zone:
+                
+                debug_CoT = gr.Textbox(label="Chain of Thoughts")
+                debug_jobapp = gr.Textbox(label="Job application meta data")
+            cover_letter_text = gr.Textbox(label="Cover Letter")
             cover_letter_pdf = gr.File(
                 label="Cover Letter PDF",
                 file_count="single",
@@ -137,16 +161,25 @@ with gr.Blocks(
                 type="filepath",
             )
             infer_btn = gr.Button("Go!", variant="primary")
+            
+
     infer_btn.click(
+        fn=prepare_input,
+        inputs=[jd_info, cv_file, cv_text],
+        outputs=[jd_info, cv_text]
+    ).then(
         fn=run_refine,
-        inputs=[weak_base, weak_key, weak_model, jd_info, cv_file, cv_text],
+        inputs=[cheap_base, cheap_key, cheap_model, jd_info, cv_text],
         outputs=[min_jd, min_cv],
-        concurrency_limit=5,
+    ).then(fn=lambda:[gr.Accordion("Expert Zone", open=True),gr.Accordion("Reformatting", open=False)],inputs=None, outputs=[expert_zone, reformat_zone]
+    ).then(fn=run_compose, inputs=[strong_base, strong_key, strong_model, min_jd, min_cv], outputs=[debug_CoT]                      
+    ).then(fn=lambda:gr.Accordion("Expert Zone", open=False),inputs=None, outputs=[expert_zone]
+    ).then(fn=finalize_letter_txt, inputs=[cheap_base, cheap_key, cheap_model, debug_CoT, jd_info, cv_text], outputs=[cover_letter_text, debug_jobapp]
     )
 
 
 if __name__ == "__main__":
     init()
-    demo.queue(max_size=10).launch(
+    app.queue(max_size=10, default_concurrency_limit=1).launch(
         show_error=True, debug=True, share=IS_SHARE
     )

config.py

@@ -5,7 +5,7 @@ OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") or ""
 
 CHEAP_API_BASE = os.getenv("CHEAP_API_BASE") or OPENAI_API_BASE
 CHEAP_API_KEY = os.getenv("CHEAP_API_KEY") or OPENAI_API_KEY
-CHEAP_MODEL = os.getenv("CHEAP_MODEL") or "gpt-3.5-turbo"
+CHEAP_MODEL = os.getenv("CHEAP_MODEL") or "gpt-4"
 
 STRONG_API_BASE = os.getenv("STRONG_API_BASE") or OPENAI_API_BASE
 STRONG_API_KEY = os.getenv("STRONG_API_KEY") or OPENAI_API_KEY

taskAI.py

@@ -1,28 +1,26 @@
+import json
+
 from llama_index.llms.openai_like import OpenAILike
 from llama_index.core.llms import ChatMessage  # , MessageRole
 from llama_index.core import ChatPromptTemplate
 
 from util import mylogger
-
-logger = mylogger(__name__,'%(asctime)s:%(levelname)s:%(message)s')
-info = logger.info
-
-
+logger = mylogger(__name__,'%(asctime)s:%(filename)s:%(levelname)s:%(message)s')
 ## define templates
 
 ### topic,input
-JD_PREPROCESS = ChatPromptTemplate(
+EXTRACT_INFO = ChatPromptTemplate(
     [
         ChatMessage(
             role="system",
-            content="You are a content extractor. You never paraphrase; you only reduce content at the sentence level. Your mission is to extract information directly related to {topic} from user input. Make sure output contains complete information.",
+            content="You are a content extractor. You never paraphrase; you only reduce content at the sentence level. Your mission is to extract {to_extract} from user input. Make sure output is complete without missing parts. Output is in a clean text format",
         ),
         ChatMessage(role="user", content="{input}"),
     ]
 )
 
 ### input
-CV_PREPROCESS = ChatPromptTemplate(
+SIMPLIFY_MD = ChatPromptTemplate(
     [
         ChatMessage(
             role="system",
@@ -32,23 +30,39 @@ CV_PREPROCESS = ChatPromptTemplate(
     ]
 )
 
-## basic func
+### template, content
+JSON_API = ChatPromptTemplate(
+    [
+        ChatMessage(
+            role="system",
+            content="You are an AI JSON API. You convert user input into a JSON object. API returns exactly in this template: {template}",
+        ),
+        ChatMessage(role="user", content="{content}"),
+    ]
+)
+keys_to_template = lambda keys : json.dumps(dict().fromkeys(keys, ""))
 
+### resume, jd
+LETTER_COMPOSE = ChatPromptTemplate(
+    [
+        ChatMessage(
+            role="system",
+            content="""You are a thoughtful wordsmith. You have a deep understanding of the scoiety and the bussiness world. You are always willing to help people find a job. Your mission is to write a compelling cover letter tailored for user to get the specified job, based on the provided RESUME and JOB_DESCRIPTION. Your writing is based on ground truth and you never fabricate anything you are unsure about.
 
-def oai(base: str, key: str, model: str, **kwargs) -> OpenAILike:
-    return OpenAILike(
-        api_base=base,
-        api_key=key,
-        model=model,
-        is_chat_model=True,
-        context_window=window_size,
-        **kwargs,
-    )
+Before officially write the letter, think step by step. First, list what makes a perfect cover letter in general, and in order to write a perfect cover letter, what key points do you have to learn from the RESUME and JOB_DESCRIPTION. Then, carefully analyze the given RESUME and JOB_DESCRIPTION, take a deep breath and propose 3 best tactics to convince recruiter believe the applicant fit for the role. Ensure your thoughts are express clearly and then write the complete cover letter.""",
+        ),
+        ChatMessage(role="user", content="<RESUME>\n{resume}\n</RESUME>\n\n<JOB_DESCRIPTION>\n{jd}</JOB_DESCRIPTION>\n"),
+    ]
+)
 
+## basic func
 
 ## tasks
 class TaskAI(OpenAILike):
     def __init__(self, api: dict[str, str], **kwargs):
+        
+        log = logger.info
+
         def guess_window_size(model=api["model"]):
             _mid = model.lower()
             windows: dict = {
@@ -60,15 +74,37 @@ class TaskAI(OpenAILike):
             for ws, names in windows.items():
                 if any([n in _mid for n in names]):
                     window_size = ws
-            info(f"use context window size: {window_size} for {model}")
+            log(f"use context window size: {window_size} for {model}")
             return window_size
 
         super().__init__(
             api_base=api["base"], api_key=api["key"], model=api["model"], is_chat_model=True, context_window=guess_window_size(), **kwargs
         )
 
-    def jd_preprocess(self, topic: str, input: str):
-        return self.stream_chat(JD_PREPROCESS.format_messages(topic=topic, input=input))
+    def jd_preprocess(self, input: str):
+        return self.stream_chat(EXTRACT_INFO.format_messages(to_extract="information directly related to job description", input=input))
 
     def cv_preprocess(self, input: str):
-        return self.stream_chat(CV_PREPROCESS.format_messages(input=input))
+        return self.stream_chat(SIMPLIFY_MD.format_messages(input=input))
+
+    def compose_letter_CoT(self, resume: str, jd: str):
+        return self.stream_chat(LETTER_COMPOSE.format_messages(resume=resume, jd=jd))
+
+    def get_jobapp_meta(self, JD, CV):
+        meta_JD = self.chat(JSON_API.format_messages(template=keys_to_template(["company_full_name", "job_title"]), content=JD)).message.content
+        # yield meta_JD
+        meta_CV = self.chat(JSON_API.format_messages(template=keys_to_template(["applicant_full_name", "applicant_contact_information"]), content=CV)).message.content
+        # yield meta_JD+'\n'+meta_CV
+        try:
+            meta_JD = json.loads(meta_JD.strip())
+            meta_CV = json.loads(meta_CV.strip())
+        except:
+            raise ValueError(f"AI didn't return a valid JSON string. Try again or consider a better model for CheapAI. \n{meta_JD}\n{meta_CV}")
+        meta = dict()
+        meta.update(meta_JD)
+        meta.update(meta_CV)
+        yield json.dumps(meta, indent=2)
+
+    def purify_letter(self, full_text):
+        return self.stream_chat(EXTRACT_INFO.format_messages(to_extract="the letter part from greeting to sign-off, and remove applicant's name at end", input=full_text))
+

test.py

@@ -28,5 +28,5 @@ def test_taskAI():
         print(chunk)
 
 if __name__ == "__main__":
-    
+    test_taskAI()
     # integration()

util.py

@@ -2,12 +2,13 @@ import tiktoken
 
 from urllib.parse import urlparse
 import requests
-
 import logging
 
+from typing import Generator
+
 def mylogger(name, format, level=logging.INFO):
     # Create a custom logger
-    logger = logging.getLogger("custom_logger")
+    logger = logging.getLogger(name)
     logger.setLevel(level)
     # Configure the custom logger with the desired settings
     formatter = logging.Formatter(format)
@@ -42,3 +43,22 @@ def is_valid_openai_api_key(api_base:str, api_key: str)->bool:
 
 def zip_api(api_base:str, api_key:str, model:str)->dict[str, str]:
     return {"base": api_base, "key": api_key, "model": model}
+
+def stream_together(*gens: Generator):
+    ln=len(gens)
+    result = [""] * ln # Mind type here
+    while 1:
+        stop: bool = True
+        for i in range(ln):
+            try:
+                n=next(gens[i])
+                if "delta" in dir(n):
+                    n=n.delta
+                result[i] += n
+                stop = False
+            except StopIteration:
+                # info(f"gen[{i}] exhausted")
+                pass
+        yield result
+        if stop:
+            break