from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate
from langchain_openai import ChatOpenAI
from calque import CalqueAPI

# Initialize the Calque API client
calque = CalqueAPI(api_key="YOUR_API_KEY")

# Define tools for the agent
tools = [
    Tool(
        name="Weather Tool",
        func=calque.call_agent("weather-service"),
        description="Get current weather information for any location"
    ),
    Tool(
        name="Calculator",
        func=calque.call_agent("math-calculator"),
        description="Useful for performing complex calculations"
    )
]

llm = ChatOpenAI(temperature=0)
agent = LLMSingleActionAgent(llm_chain=llm_chain, tools=tools)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools)

result = agent_executor.run("What's the weather in Tokyo? Then calculate 5% of the temperature in Celsius.")
print(result)

import autogen
from calque import CalqueAPI

# Initialize the Calque API client
calque = CalqueAPI(api_key="YOUR_API_KEY")

# Define an agent that uses Calque services
user_proxy = autogen.UserProxyAgent(
    name="User",
    system_message="I need assistance with a task.",
    human_input_mode="TERMINATE"
)

calque_agent = autogen.AssistantAgent(
    name="CalqueAssistant",
    system_message="""You can use Calque agents to solve problems.
                      Available agents: 'image-generator', 'text-translator', 'data-processor'.""",
    llm_config={"config_list": config_list}
)

# Setup functions for calling Calque agents
@calque_agent.register_for_execution()
def call_calque_agent(agent_name, input_data):
    return calque.call_agent(agent_name, input_data)

# Start conversation
user_proxy.initiate_chat(calque_agent, message="Generate an image of a sunset and translate 'beautiful sunset' to French")

from crewai import Agent, Task, Crew
from calque import CalqueAPI

# Initialize the Calque API client
calque = CalqueAPI(api_key="YOUR_API_KEY")

# Define agents with Calque integration
researcher = Agent(
    role="Researcher",
    goal="Find information on renewable energy trends",
    backstory="Experienced data analyst with expertise in energy sector",
    tools=[calque.get_agent_as_tool("data-searcher")]
)

writer = Agent(
    role="Writer",
    goal="Create an informative report on renewable energy",
    backstory="Technical writer with expertise in scientific papers",
    tools=[calque.get_agent_as_tool("content-writer")]
)

# Create tasks
research_task = Task(
    description="Research the latest trends in solar and wind energy",
    agent=researcher
)

writing_task = Task(
    description="Write a 3-page report on renewable energy findings",
    agent=writer
)

# Create a crew with the agents
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=2
)

# Execute the crew's tasks
result = crew.kickoff()
print(result)

from llama_index.core import VectorStoreIndex, Document, SimpleDirectoryReader
from llama_index.core.agent import ReActAgent
from llama_index.llms.openai import OpenAI
from calque import CalqueAPI

# Initialize the Calque API client
calque = CalqueAPI(api_key="YOUR_API_KEY")

# Load documents
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

# Set up the LLM
llm = OpenAI(model="gpt-4")

# Create a tool for accessing Calque agents
calque_tools = [
    calque.get_tool("document-summarizer"),
    calque.get_tool("data-visualizer")
]

# Create the agent with tools
agent = ReActAgent.from_tools(
    tools=[query_engine.as_tool(), *calque_tools],
    llm=llm,
    verbose=True
)

# Use the agent
response = agent.chat("Summarize the documents and create a visualization of the main topics")
print(response)

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import AzureTextCompletion
from calque import CalqueAPI

# Initialize the kernel
kernel = sk.Kernel()

# Add OpenAI service
kernel.add_text_completion_service(
    "gpt",
    AzureTextCompletion("text-davinci-003")
)

# Initialize the Calque API client
calque = CalqueAPI(api_key="YOUR_API_KEY")

# Register Calque agents as native functions
@kernel.native_function
def call_translation_agent(text: str, target_language: str) -> str:
    """Calls the Calque translation agent to translate text."""
    return calque.call_agent(
        "translation-agent",
        {"text": text, "target_language": target_language}
    )

@kernel.native_function
def call_analysis_agent(data: str) -> str:
    """Calls the Calque data analysis agent to analyze text."""
    return calque.call_agent(
        "analysis-agent",
        {"data": data}
    )

# Create and run a semantic function
prompt = """
Analyze the following text and then translate it to Spanish:
{{$input}}

Analysis: {{call_analysis_agent $input}}
Translation: {{call_translation_agent $input \"Spanish\"}}
"""

semantic_function = kernel.create_semantic_function(prompt)
result = semantic_function.invoke("Climate change is accelerating at an alarming rate.")
print(result)