prompt.pipe(model).pipe(parser)

const city= z.object({
  name:z.string().describe("şehrin adı"),
  population:z.number().describe("şehrin nüfusu"),
  country:z.string().describe("bulunduğu ülke"),
  continent:z.string().describe("bulunduğu kıta"),
  relevance:z.boolean().describe("eğer şehirle alakalı bir durum ise true ,yoksa false")
})

const structuredLlm = chat.withStructuredOutput(city);

console.log (await structuredLlm.invoke("türkiyenin şırnak ili hakkında bilgi almak istiyorum"));

['hizmetçi', 'görevli', 'yardımcı', 'oğlan', 'şehir']

{ population: '500bin', region: 'ege bölgesi' }

{ population: 500000, region: 'ege' }

const loader = new PuppeteerWebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/", {
    launchOptions: {
      headless: true,
      args: ['--no-sandbox']
    },
    gotoOptions: {
      waitUntil: "domcontentloaded",
    }, evaluate: async (page, browser) => {
        const paragraphs = await page.evaluate(() => {
            const pElements = Array.from(document.querySelectorAll('p'));
            return pElements.map(p => p.textContent?.trim());
        });
        
        return paragraphs.join('\n\n');
    }

  });

  const docs = await loader.load();

console.log(docs[0].pageContent)

const loader = new JSONLoader("example.json");
const docs = await loader.load();
console.log(docs);

const loader = new PDFLoader("example.pdf");
const docs = await loader.load();
console.log(docs);

const text = `
Yapay zekâ, günümüzde birçok alanda kullanılıyor. Özellikle büyük dil modelleri, metin oluşturma ve anlama konusunda büyük gelişmeler kaydetti. Bu modeller, insanların dilini anlamak ve üretmek için milyarlarca parametre içerir.
Küresel ısınma, dünyamızın karşı karşıya olduğu en büyük çevre sorunlarından biridir. Son yıllarda artan sıcaklıklar, buzulların erimesine ve deniz seviyesinin yükselmesine neden oluyor. Bu durum, kıyı bölgelerinde yaşayan milyonlarca insanı tehdit ediyor.
Sağlıklı beslenme, uzun ve kaliteli bir yaşam için temel unsurdur. Dengeli bir diyet, vücudun ihtiyaç duyduğu tüm besinleri sağlamalıdır. Sebzeler, meyveler, tam tahıllar, protein kaynakları ve sağlıklı yağlar, beslenme düzeninin ana bileşenleridir.
`;

const textSplitter = new CharacterTextSplitter({
    chunkSize: 200,
    chunkOverlap:50,
    separator:' '
})

const chunks = await textSplitter.splitText(text);
  
  console.log(`Toplam ${chunks.length} parça oluşturuldu:\n`);
  
  for (let i = 0; i < chunks.length; i++) {
    console.log(`Parça ${i+1} (${chunks[i].length} karakter):`);
    console.log(chunks[i]);
    console.log('----------------------------');
  }

const text = `
Yapay zekâ, günümüzde birçok alanda kullanılıyor. Özellikle büyük dil modelleri, metin oluşturma ve anlama konusunda büyük gelişmeler kaydetti. Bu modeller, insanların dilini anlamak ve üretmek için milyarlarca parametre içerir.
Küresel ısınma, dünyamızın karşı karşıya olduğu en büyük çevre sorunlarından biridir. Son yıllarda artan sıcaklıklar, buzulların erimesine ve deniz seviyesinin yükselmesine neden oluyor. Bu durum, kıyı bölgelerinde yaşayan milyonlarca insanı tehdit ediyor.
Sağlıklı beslenme, uzun ve kaliteli bir yaşam için temel unsurdur. Dengeli bir diyet, vücudun ihtiyaç duyduğu tüm besinleri sağlamalıdır. Sebzeler, meyveler, tam tahıllar, protein kaynakları ve sağlıklı yağlar, beslenme düzeninin ana bileşenleridir.
`;

const textSplitter = new RecursiveCharacterTextSplitter({
    chunkSize: 200,
    chunkOverlap: 75,
    separators: [
      "\n",           
      ".",              
    ]
  });



const chunks = await textSplitter.splitText(text);

  
  console.log(`Toplam ${chunks.length} parça oluşturuldu:\n`);
  
  for (let i = 0; i < chunks.length; i++) {
    console.log(`Parça ${i+1} (${chunks[i].length} karakter):`);
    console.log(chunks[i].replace(".","").trim().length);
    console.log(chunks[i].replace(".","").trim());
    console.log('----------------------------');
  }

const embedding = new ZhipuAIEmbeddings({
    apiKey:"your_api_key",
    modelName:"embedding-2"
});
const res = await embedding.embedQuery(
    "Uşak Türkiyenin en gelişmiş şehirlerindendir."
  );

console.log(res);

const vectorStore = await QdrantVectorStore.fromExistingCollection(embeddings, {
    url: "",
    collectionName: "lyngo-app"
});

await vectorStore.addDocuments(allSplits);

const chain = new RunnableSequence({
  first: runnable1,
  middle: [runnable2, runnable3]
  last: runnable4
});

const chain = RunnableSequence.from([
  runnable1,
  runnable2,
  runnable3,
  runnable4
]);

const processInputBeforeLLM=RunnableLambda.from((input:any) => {
  //inputu işle ve geriye dönder
  return input.toUpperCase();
});

const cityPrompt = ChatPromptTemplate.fromTemplate(`
  Lütfen {city} şehri hakkında bilgi ver.
  {format_instructions}
`);

const citySchema = z.object({
  name: z.string().describe("şehrin adı"),
  population: z.number().describe("şehrin nüfusu"),
  country: z.string().describe("bulunduğu ülke"),
  landmarks: z.array(z.string()).describe("önemli yapılar/yerler")
});

const cityParser = StructuredOutputParser.fromZodSchema(citySchema);

const processInputBeforeLLM=RunnableLambda.from((input:any) => {
  
  return {city:input.city.toUpperCase()};
});

const cityInfoChain = RunnableSequence.from([
  processInputBeforeLLM,
  {
    city: (input) => input.city,
    format_instructions: () => cityParser.getFormatInstructions()
  },
  cityPrompt,
  chatModel,
  cityParser
]);


const response =  await cityInfoChain.invoke({city:"kahramanmaraş"})

console.log(response);

const cityPrompt = ChatPromptTemplate.fromTemplate(`
  Lütfen {city} şehri hakkında bilgi ver.
  {format_instructions}
`);

const historyPrompt = ChatPromptTemplate.fromTemplate(`
  Lütfen {city} şehri kısa bir tariçe ver. Markdown yada herhangi bir format kullanma düz yazı yaz.
`);

const citySchema = z.object({
  name: z.string().describe("şehrin adı"),
  population: z.number().describe("şehrin nüfusu"),
  country: z.string().describe("bulunduğu ülke"),
  landmarks: z.array(z.string()).describe("önemli yapılar/yerler")
});

const cityParser = StructuredOutputParser.fromZodSchema(citySchema);

const processInputBeforeLLM=RunnableLambda.from((input:any) => {
  
  return {city:input.city.toUpperCase()};
});

const cityInfoChain = RunnableSequence.from([
  processInputBeforeLLM,
  {
    city: (input) => input.city,
    format_instructions: () => cityParser.getFormatInstructions()
  },
  cityPrompt,
  chatModel,
  cityParser
]);


const cityHistoryChain = RunnableSequence.from([
  {
    city: (input) => input.city,
  },
  historyPrompt,
  chatModel,
  (response)=>response.content
]);


const cityAnalysisPararell = RunnableParallel.from({
  cityInfo: cityInfoChain,
  cityHistory: cityHistoryChain
})

const response =  await cityAnalysisPararell.invoke({city:"kahramanmaraş"})

console.log(response);

const addToolSchema= z.object({
  a:z.number(),
  b:z.number(),
})

const addToolFunction = async({a,b}:{a:number,b:number}):Promise<string>=>{
  const result = a+b;
  return String(result);
}

const addTool= tool(
  addToolFunction,
  {
    name:"add",
    description:"verilen iki sayıyı toplar",
    schema:addToolSchema,
  }
)

const llmWithTools =  chatModel.bindTools([addTool])

const response =  await llmWithTools.invoke("3 ile 7 toplamı ?")

console.log(response);

if (response.tool_calls) {
  for (const toolCall of response.tool_calls) {
    const toolMessage = await addTool.invoke(toolCall);
    console.log("Tool sonucu:", toolMessage); 
  }
}

const agent = createReactAgent({
  llm: model,           // Dil modeli
  tools: [tool1, tool2], // Ajanın kullanacağı araçlar
  messageModifier: "prompt"  // İsteğe bağlı sistem promptu
});

const magicTool = tool(
  async ({ input }: { input: number }) => {
    return `${input + 2}`;
  },
  {
    name: "magic_function",
    description: "Applies a magic function to an input.",
    schema: z.object({
      input: z.number(),
    }),
  }
);
const tools = [magicTool];

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant"],
  ["human", "{input}"],
  ["placeholder", "{agent_scratchpad}"],
]);

const agent = createToolCallingAgent({
  llm:model,
  tools,
  prompt,
});

const agentExecutor = new AgentExecutor({
  agent,
  tools,
});

const query = "what is the value of magic_function(3)?";

const response = await agentExecutor.invoke({ input: query });

const magicTool = tool(
  async ({ input }: { input: number }) => {
    return `${input + 2}`;
  },
  {
    name: "magic_function",
    description: "Applies a magic function to an input.",
    schema: z.object({
      input: z.number(),
    }),
  }
);
const tools = [magicTool];

const app = createReactAgent({
  llm:model,
  tools,
});

const query = "what is the value of magic_function(3)?";

const response = await app.invoke(
  {
    messages: [
      {
        role: "human",
        content: query,
      },
    ],
  })

console.log(response);

const query = "what is the value of magic_function(3)?";

const response = await app.invoke(
  {
    messages: [
      {
        role: "human",
        content: query,
      },
    ],
  })

  const messageHistory =  response.messages;
  const newQuery = "Pardon?";
 const agentOutput = await app.invoke({
    messages: [...messageHistory, { role: "user", content: newQuery }],
  });

  console.log(agentOutput);

const modifyMessages = (messages: BaseMessage[]) => {
  return [
    new SystemMessage(`You are a helpful assistant. you should only answer in}`),
    ...messages,
    new HumanMessage("Also say 'Pandemonium!' after the answer."),
  ];
};

const app = createReactAgent({
  llm:model,
  tools,
  messageModifier:modifyMessages
});



const query = "what is the value of magic_function(3)?";

const runAgent= async(query:string, language:string)=>{
  const response = await app.invoke(
    {
      messages: [
        {
          role: "system",
          content: `you should only answer in ${language}`
        },
        {
          role: "human",
          content: query,
        },
      ],
    }
    )
  return response;
}


const response =  await runAgent(query,"turkish")
console.log(response);

const thread_id = "id_1"
const checkpointer = new MemorySaver();

const app = createReactAgent({
  llm:model,
  tools,
  messageModifier:modifyMessages,
  checkpointSaver: checkpointer,
});

const langGraphConfig = {
  configurable: {
    thread_id: thread_id,
  },
};
const query = "what is the value of magic_function(3)?";
const language="turkish"

const runAgent= async(query:string, language:string)=>{
  const response = await app.invoke(
    {
      messages: [
        {
          role: "system",
          content: `you should only answer in ${language}`
        },
        {
          role: "human",
          content: query,
        },
      ],
    },langGraphConfig
    )
  return response;
}

const response =  await runAgent(query,language)
console.log(response);

console.log("**********************************************\n");


const query2= "benim adım hüseyin";
const response2= await runAgent(query2,language)
console.log(response2);

console.log("**********************************************\n");

const query3= "what is the value of magic_function(3)";
const response3= await runAgent(query3,language)
console.log(response3);
console.log("*********************************************\n");


const query4= "benim adımı hatırlıyor musun?";
const response4= await runAgent(query4,language)
console.log(response4);

const query = "what is the value of magic_function(3)?";
const language="turkish"

  const response = await app.stream(
    {
      messages: [
        {
          role: "system",
          content: `you should only answer in ${language}`
        },
        {
          role: "human",
          content: query,
        },
      ],
    },langGraphConfig
    )
   
    for await (const step of response) {
      // Her bir adımı görüntüle
      console.log("Adım türü:", Object.keys(step)[0]);
      
      // Agent mesajları varsa
      if (step.agent && step.agent.messages && step.agent.messages.length > 0) {
        const message = step.agent.messages[0];
        // Mesaj içeriğini yazdır
        if (message.content !== undefined && message.content !== "") {
          console.log("AI içeriği:", message.content);
        } else if (message.tool_calls && message.tool_calls.length > 0) {
          console.log("Araç çağrısı:", JSON.stringify(message.tool_calls, null, 2));
        }
      }
      
      // Tool mesajları varsa
      if (step.tools && step.tools.messages && step.tools.messages.length > 0) {
        const toolMsg = step.tools.messages[0];
        console.log("Araç yanıtı:", toolMsg.content);
      }
      
      console.log("-------------------");
    }

const badMagicTool = tool(
  async ({ input: _input }) => {
    return "Almost there! Try again with the same input to get the correct result.";
  },
  {
    name: "magic_function",
    description: "Applies a magic function to an input.",
    schema: z.object({
      input: z.string(),
    }),
  }
);

const badTools = [badMagicTool];

const RECURSION_LIMIT = 2 * 2 + 1;
const appWithBadTools = createReactAgent({ llm:model, tools: badTools });
const query = "what is the value of magic_function('3')?";
try {
 const response =  await appWithBadTools.invoke(
    {
      messages: [{ role: "user", content: query }],
    },
    {
      recursionLimit: RECURSION_LIMIT,
    }
  );
  console.log("response:",response);
  
} catch (e) {
  if (e instanceof GraphRecursionError) {
    console.log("Recursion limit reached.");
  } else {
    throw e;
  }
}

const prompts = {
    routerLLM:
        ChatPromptTemplate.fromMessages([
            ["system","Kullanıcı girdisi içeriğine göre `blogPost`,`emailDraft` ya da  `linkedinJob`yönlendir "],
            ["user","{input}"]
        ]),
    linkedinJobPrompt:
        ChatPromptTemplate.fromTemplate(`
    LinkedIn'deki abartılı iş ilanları paylaşmakta uzman bir insan kaynakları uzmanısın\n 
    Aranan pozisyonu efsaneleştir ve yüceltmelisin: \n
    1) Gerçekçi olmayan nitelikler iste ('ninja', 'guru' gibi),\n 
    2) Düşük ücreti süslü ifadelerle gizle (aile ortamı, üst düzey deneyim),\n 
    3) Sıradan şirketi unicorn gibi göster, \n
    4) Belirsiz tanımla birden çok iş yaptıracağını ima et.\n
    
    İşte düzenlemen gereken iş ilanı {input}
    !Önemli sadece oluşturmuş olduğun iş ilanını yaz, başka birşey ekleme.
    `),
    emailDraftPrompt:
        ChatPromptTemplate.fromTemplate(`
    Sen kullanıcının girdisine göre kullanıcıya e-posta taslağı oluşturan bir uzmansın\n
    İşte kullanıcının girdisi:{input} \n
    !Önemli sadece oluşturmuş olduğun taslağı yaz, başka birşey ekleme.
    `),
    blogPost: 
        ChatPromptTemplate.fromTemplate(`
    Sen kullanıcının girdisindeki konuya göre blog post oluşturan, uzman bir bloggersın.
    İşte kullanıcının girdisi: {input}\n
    !Önemli sadece oluşturmuş olduğun blog postunu yaz, başka birşey ekleme.
    `)
}

async function callLinkedinHR (state:typeof StateAnnotation.State){
    const response =  await prompts.linkedinJobPrompt.pipe(llm).invoke({
        input:state.input
    })

    return {output:response.content}
}

async function callEmailDrafCreator (state:typeof StateAnnotation.State){
    const response = await prompts.emailDraftPrompt.pipe(llm).invoke({
         input:state.input
    })

    return {output:response.content}
}

async function callBlogger(state:typeof StateAnnotation.State){
    const response = await prompts.blogPost.pipe(llm).invoke({
        input:state.input
    })

    return {output:response.content}
}

function routerDecision (state:typeof StateAnnotation.State){
    if(state.decision=="linkedinJob") return "callLinkedinHR"
    if(state.decision=="blogPost") return "callBlogger"
    if(state.decision=="emailDraft") return "callEmailDrafCreator"

    return "__end__"
}

const workFlow = new StateGraph(StateAnnotation)
.addNode("callLinkedinHR",callLinkedinHR)
.addNode("callBlogger",callBlogger)
.addNode("callEmailDrafCreator",callEmailDrafCreator)
.addNode("callRouter",callRouter)

.addEdge("__start__","callRouter")
.addConditionalEdges
    ("callRouter",
      routerDecision,
      ["callBlogger","callEmailDrafCreator","callLinkedinHR","__end__"]
    )
.addEdge("callBlogger","__end__")
.addEdge("callEmailDrafCreator","__end__")
.addEdge("callLinkedinHR","__end__")

.compile()

new Send(node:string,args:any):Send

const sectionSchema = z.object({
  name: z.string().describe("GÖrevin bu bölümü için isim"),
  desciription : z.string().describe("Ana görevin dışına çıkmadan,bu görevde ele alınacak konuya dair açıklama")
})

const sectionsSchema = z.object({
  sections : z.array(sectionSchema).describe("Ana göreve ait alt görevler")
})

const planner = llm.withStructuredOutput(sectionsSchema);

async function orchastrator(state:any){
  const response = await planner.invoke([
     {role:"system",content:"Görevi alt görevlere böl."},
     {role:"user",content:`İşte görev : ${state.input}`}
  ])

  console.log(response);
  
}
await orchastrator({input:"LLMler hakkında bilgi istiyorum"})

const GraphState = Annotation.Root({
  input:Annotation<string>(),
  sections:Annotation<Array<z.infer<typeof sectionSchema>>>()
})

async function orchastrator(state:typeof GraphState.State){
  const response = await planner.invoke([
     {role:"system",content:"Görevi alt görevlere böl."},
     {role:"user",content:`İşte görev : ${state.input}`}
  ])

  return {sections:response.sections}  
}

async function procesesSection(state:any){
  const response = await llm.invoke([
    {role:"system",content:"Verilen görevi, görev adı ve görev açıklamasına bağlı olarak gerçekleştir. Sadece görevi yerine getir başka birşey ekleme."},
    {role:"user", content:`İşte görev:\n 
            görev adı : ${state.section.name} \n
            görev açıklaması : ${state.section.desciription}
      `}
  ])

  console.log(response.content)
}

await procesesSection({section:{
  name:"LLM Hakkında genel bilgi",
  description:"Bu görev, büyük dil modelleri (LLM'ler) hakkında bilgi edinmeyi amaçlamaktadır.  LLM'lerin tarihçesi, çalışma prensipleri, kullanım alanları, avantajları ve dezavantajları gibi konular ele alınacaktır."
}})

const WorkerState = Annotation.Root({
  section :Annotation<z.infer<typeof sectionSchema>>,
  completedSection:Annotation<string[]>({
    default:()=>[],
    reducer:(a,b)=>a.concat(b)
  })
})

function assignSectionToWorkers(state:any){
   state.sections.map((section:any)=>{
      //sections içerisinde bulunan her section'ı procesesSection'a göndereceğiz
      console.log(section);
      
   })
}

assignSectionToWorkers({sections: [
  {
    name: 'LLM Hakkında Genel Bilgi',
    desciription: "Bu görev, büyük dil modelleri (LLM'ler) hakkında bilgi edinmeyi amaçlamaktadır.  LLM'lerin tarihçesi, çalışma prensipleri, kullanım alanları, avantajları ve dezavantajları gibi konular ele alınacaktır."
  },
  {
    name: 'Eğitim ve Veri Detayları',
    desciription: "LLM'lerin nasıl eğitildiği ve hangi verilerle beslendiği gibi teknik detaylara odaklanılacak."
  },
  {
    name: 'Uygulama Alanları',
    desciription: "LLM'lerin kullanıldığı farklı uygulamalar ve sektörler ayrıntılı olarak incelenecektir. Örneğin, metin oluşturma, çeviri, kodlama gibi."
  },
  {
    name: 'Avantajlar ve Dezavantajlar / Etik ve Toplumsal Etkiler',
    desciription: "LLM'lerin güçlü ve zayıf yönleri ele alınacak. Avantajlar ve dezavantajlar, etik kaygılar, toplumsal etkileri ile birlikte değerlendirilecektir."
  },
  {
    name: 'Gelecek Trendleri ve Potansiyel',
    desciription: "Gelecekte LLM'lerin kullanım alanları ve potansiyel gelişimi hakkında öngörüler içerecektir."
  }
]
})

function assignSectionToWorkers(state:any){
   state.sections.map((section:any)=>{
      new Send("procesesSection",{section})      
   })
}

const GraphState = Annotation.Root({
  input:Annotation<string>(),
  sections:Annotation<Array<z.infer<typeof sectionSchema>>>(),
  completedSection:Annotation<string[]>({
    default:()=>[],
    reducer:(a,b)=>a.concat(b)
  }),
  finalAnswer:Annotation<string>()
})

function synthesizer(state:typeof GraphState.State){
  const completedSection = state.completedSection;
  const completedSectionFinalAnswer = completedSection.join('\n\n*#*#*#*\n\n')
  return {finalAnswer:completedSectionFinalAnswer};
} 

const workFlow = new StateGraph(GraphState)
.addNode("orchastrator",orchastrator)
.addNode("procesesSection",procesesSection)
.addNode("synthesizer",synthesizer)

.addEdge("__start__","orchastrator")
.addConditionalEdges("orchastrator",assignSectionToWorkers,["procesesSection"])
.addEdge("procesesSection","synthesizer")
.addEdge("synthesizer","__end__")

.compile()

const tool = new DuckDuckGoSearch({ maxResults: 2 });

const toolResponse = await tool.invoke("Ekrem imamoğlu neden tutuklandı");

console.log(toolResponse);

const prompt = ChatPromptTemplate.fromMessages([
  ["system", `Sen yardımcı bir yapay zeka asistanısın. İnternette arama yapacağın zaman kullanıcının girdisini ingilizceye çevirip arama yap.
    Çünkü kullanıcının dilinde web aramaları hükümetler tarafından istismar edilebilir. Elde ettiğin arama  sonuçlarını kullanıcıya uygun bir şekilde sun.`],
  ["placeholder", "{messages}"],
]);

const tool = new DuckDuckGoSearch({ maxResults: 2 });
const llmWithTools = chatModel.bindTools([tool]);

const chain = prompt.pipe(llmWithTools);

const toolChain = RunnableLambda.from(async (userInput: string, config) => {
  const humanMessage = new HumanMessage(userInput);
  const aiMsg = await chain.invoke(
    {
      messages: [new HumanMessage(userInput)],
    },
    config
  );
  console.log("aiMsg:", aiMsg);
  
  const toolMsgs = await tool.batch((aiMsg.tool_calls as any), config);
  console.log("toolMsgs:", toolMsgs);
  
  return chain.invoke(
    {
      messages: [humanMessage, aiMsg, ...toolMsgs],
    },
    config
  );
});

const toolChainResult = await toolChain.invoke(
  "Ekrem imamoğlu neden tutuklandı",
);

console.log("toolChainResult", toolChainResult);

// llm'e problemi analiz edip çözümü matematiksel olarak
// çözecek olan python kodu üretmesi için talimat veriyoruz.
const prompt = ChatPromptTemplate.fromTemplate(
  `You are an expert who analyzes the problem and writes the python code that will solve the problem mathematically.
  Generate python code that does {input}. Do not generate anything else. 

  IMPORTANT: Your response must ONLY contain the raw Python code with NO MARKDOWN, NO BACKTICKS, and NO CODE BLOCK FORMATTING.
  IMPORTANT: Only do mathematical operations, do not draw any graphs etc. and ONLY USE numpy,scipy LIBRARY
  Just write the executable Python code and nothing else.
  `
);

// llm sürekli ```python\n``` ile başlayan ve biten kod blokları
// ürettiği için bu çıktıyı temizlemek için aşağıdaki fonksiyonu yazdım
// çıktınızı kontrol ederek gereksiz sadece kodu elde edecek şekilde 
///düzenleyebilirsiniz.
const cleanCodeOutput = (rawOutput:any) => {
  console.log(rawOutput);
  let cleaned = rawOutput.replace(/```python\n?|```\n?/g, '');
  cleaned = cleaned.trim();
  return cleaned;
};



//interpreter tool'u initialize ediyoruz
const interpreter = await PythonInterpreterTool.initialize({
  indexURL: "/home/hc/LangchainDemo/node_modules/pyodide",
});

//interpreter tool'a numpy ve scipy paketlerini ekliyoruz
//promptunuzda başka paketler kullanmanız gerekiyorsa buraya ekleyiniz
// Pyodide tüm paketleri desteklemez bu yüzden kullanacağınız
// paketlerin pyodide tarafından desteklenip desteklenmediğini kontrol ediniz
await interpreter.addPackage("numpy");
await interpreter.addPackage("scipy");

//chaini oluşturuyoruz
// prompt -> chatModel -> StringOutputParser -> RunnableLambda -> interpreter
// şeklinde bir chain oluşturuyoruz
const chain = prompt
  .pipe(chatModel)
  .pipe(new StringOutputParser())
  .pipe(new RunnableLambda({ func: cleanCodeOutput }))
  .pipe(interpreter);

const result = await chain.invoke({
  input: `Bir şirket üç farklı ürün üretiyor ve bu ürünleri A, B ve C olarak adlandırıyor. Şirket, A ürününden birim başına 240 TL, B ürününden birim başına 320 TL ve C ürününden birim başına 180 TL kâr elde ediyor.
Her A ürünü için 2 saat üretim zamanı, 1 saat paketleme zamanı gerekiyor.
Her B ürünü için 3 saat üretim zamanı, 2 saat paketleme zamanı gerekiyor.
Her C ürünü için 1 saat üretim zamanı, 1 saat paketleme zamanı gerekiyor.
Şirketin bir haftada maksimum 240 saat üretim zamanı ve 140 saat paketleme zamanı vardır.
Şirket maksimum kârı elde etmek için hangi üründen kaç adet üretmelidir ve bu durumda toplam kâr ne kadar olacaktır?Bir fabrika her saat 120 parça üretiyor. Bu parçaların %5'i kusurlu çıkıyor. Fabrika günde 8 saat çalışıyor. Bir haftalık (5 iş günü) çalışma süresinde toplam kaç adet kusursuz parça üretilir?
`,
});

console.log(JSON.parse(result).stdout);

const tool = new WikipediaQueryRun({
  topKResults: 1,
  maxDocContentLength: 4000,
  baseUrl:"https://tr.wikipedia.org/w/api.php"
});

const res = await tool.invoke("vaka-i vakvakiye");

console.log(res);

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts"
import { CommaSeparatedListOutputParser, StructuredOutputParser, JsonOutputParser, StringOutputParser } from "@langchain/core/output_parsers";
import { StateGraph, Annotation, Send, GraphRecursionError } from "@langchain/langgraph";
import { RunnableLambda, RunnableParallel, RunnableSequence } from "@langchain/core/runnables";
import { tool } from "@langchain/core/tools";
import { BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { PuppeteerWebBaseLoader } from "@langchain/community/document_loaders/web/puppeteer";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { ZhipuAIEmbeddings } from "@langchain/community/embeddings/zhipuai";
import { CharacterTextSplitter, RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { DuckDuckGoSearch } from "@langchain/community/tools/duckduckgo_search";
import { PythonInterpreterTool } from "@langchain/community/experimental/tools/pyinterpreter";
import { WolframAlphaTool } from "@langchain/community/tools/wolframalpha";
import { WikipediaQueryRun } from "@langchain/community/tools/wikipedia_query_run";
import { WebBrowser } from "langchain/tools/webbrowser";
import { tool } from "@langchain/core/tools";
import { createToolCallingAgent } from "langchain/agents";
import { AgentExecutor } from "langchain/agents";
import { ChatMessageHistory } from "@langchain/community/stores/message/in_memory";
import { MemorySaver } from "@langchain/langgraph";