LangChain

OPENAI_API_KEY="your_openai_api_key_here"
NEATLOGS_API_KEY="your_neatlogs_api_key_here"

from dotenv import load_dotenv
import os

# Load environment variables from .env file
load_dotenv()

os.getenv("OPENAI_API_KEY")
os.getenv("NEATLOGS_API_KEY")

from langchain_google_genai import ChatGoogleGenerativeAI
from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from neatlogs_test.integration.callbacks.langchain import NeatlogsLangchainCallbackHandler
import os
load_dotenv()

# Create an instance of the handler with API key
handler = NeatlogsLangchainCallbackHandler(api_key="api_key"
                                           )

prompt1 = PromptTemplate(
    template='Generate a detailed report on {topic}',
    input_variables=['topic']
)

prompt2 = PromptTemplate(
    template='Generate a 5 pointer summary from the following text \n {text}',
    input_variables=['text']
)

model = ChatGoogleGenerativeAI(
    model="gemini-1.5-flash",
    google_api_key=os.getenv("GEMINI_API_KEY"),
)

parser = StrOutputParser()

chain = prompt1 | model | parser | prompt2 | model | parser

# Pass the handler to the invoke method to track all intermediate steps
result = chain.invoke(
    {'topic': 'Current state of Artificial Intelligence.'},
    config={'callbacks': [handler]}
)

print(result)

import asyncio
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from neatlogs_test.integration.callbacks.langchain import AsyncNeatlogsLangchainCallbackHandler

async def async_example():
    # Use the async handler for async workflows
    async_handler = AsyncNeatlogsLangchainCallbackHandler(api_key="api_key")

    llm = OpenAI()
    chain = LLMChain(llm=llm, callbacks=[async_handler])

    # Use with async chains
    result = await chain.arun("Hello world")
    return result

# Run the async example
asyncio.run(async_example())

import os
import asyncio
from dotenv import load_dotenv
from langchain_openai.chat_models import AzureChatOpenAI
from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.schema import HumanMessage
from neatlogs_test.integration.callbacks.langchain import AsyncNeatlogsLangchainCallbackHandler

load_dotenv()

handler = AsyncNeatlogsLangchainCallbackHandler(
    api_key='Ovz4IsUEZ0qHv6ZXSgpN-tU4CuZKLTko', tags=['async-workflow'])


# ======== LLM Clients ========
# Pass the handler in the constructor's callback list
azure_llm = AzureChatOpenAI(
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    api_version=os.environ["AZURE_OPENAI_API_VERSION"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    azure_deployment=os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"],
    callbacks=[handler]
)

gemini_llm = ChatGoogleGenerativeAI(
    model="gemini-1.5-flash",
    google_api_key=os.getenv("GEMINI_API_KEY"),
    callbacks=[handler]
)

# ======== Topics ========
topics = [
    "quantum computing",
    "renewable energy storage",
    "deep-sea ecosystems",
    "urban vertical farming"
]

# ======== Individual Tasks ========


async def call_azure(topic: str, idx: int):
    try:
        prompt = f"Write a short, 30-word insight about {topic}."
        # No need to pass handler to ainvoke if it's in the constructor
        resp = await azure_llm.ainvoke(prompt)
        return f"[Azure-{idx}] {resp.content}"
    except Exception as e:
        return f"[Azure-{idx} ERROR] {e}"


async def call_gemini(topic: str, idx: int):
    try:
        prompt = f"Give a creative, 30-word fact about {topic}."
        # No need to pass handler to ainvoke if it's in the constructor
        resp = await gemini_llm.ainvoke([HumanMessage(content=prompt)])
        return f"[Gemini-{idx}] {resp.content}"
    except Exception as e:
        return f"[Gemini-{idx} ERROR] {e}"

# ======== Main Orchestration ========


async def main():
    azure_tasks = [call_azure(t, i) for i, t in enumerate(topics, start=1)]
    gemini_tasks = [call_gemini(t, i) for i, t in enumerate(topics, start=1)]

    print("🚀 Launching Azure + Gemini calls asynchronously...\n")
    all_responses = await asyncio.gather(*azure_tasks, *gemini_tasks, return_exceptions=False)

    # Strip only message content for summarization
    cleaned_responses = [r.split("] ", 1)[-1] for r in all_responses]
    combined_text = "\n".join(cleaned_responses)

    final_prompt = f'''
    Summarize the following insights into a single, cohesive paragraph:
    ---
    {combined_text}
    '''
    # No need to pass handler to ainvoke if it's in the constructor
    final_resp = await azure_llm.ainvoke(final_prompt)

    print("\n✅ FINAL MERGED SUMMARY:\n")
    print(final_resp.content)

if __name__ == "__main__":
    asyncio.run(main())