RANA vs LangChain

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";

const model = new ChatOpenAI({
  modelName: "gpt-4",
  temperature: 0.7,
});

const messages = [
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("Hello!"),
];

const response = await model.invoke(messages);
console.log(response.content);

import { createRana } from '@rana/core';

const rana = createRana();

const response = await rana.chat('Hello!');
console.log(response.content);

import { ChatOpenAI } from "@langchain/openai";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const weatherTool = tool(
  async ({ location }) => {
    return `Weather in ${location}: Sunny, 72°F`;
  },
  {
    name: "get_weather",
    description: "Get weather for a location",
    schema: z.object({
      location: z.string(),
    }),
  }
);

const model = new ChatOpenAI({
  modelName: "gpt-4",
}).bindTools([weatherTool]);

const response = await model.invoke("What's the weather in SF?");
// Handle tool calls manually...

import { createRana, createTool } from '@rana/core';

const rana = createRana();

const weather = createTool({
  name: 'get_weather',
  description: 'Get weather for a location',
  parameters: { location: { type: 'string' } },
  handler: ({ location }) => `Weather in ${location}: Sunny, 72°F`,
});

const response = await rana
  .tools([weather])
  .chat('What\'s the weather in SF?');

import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
import { MemoryVectorStore } from "langchain/vectorstores/memory";
import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
import { createRetrievalChain } from "langchain/chains/retrieval";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
import { ChatPromptTemplate } from "@langchain/core/prompts";

const embeddings = new OpenAIEmbeddings();
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});

const docs = await splitter.createDocuments([text]);
const vectorStore = await MemoryVectorStore.fromDocuments(docs, embeddings);
const retriever = vectorStore.asRetriever();

const prompt = ChatPromptTemplate.fromTemplate(`
Answer based on context: {context}
Question: {input}
`);

const documentChain = await createStuffDocumentsChain({
  llm: new ChatOpenAI(),
  prompt,
});

const retrievalChain = await createRetrievalChain({
  combineDocsChain: documentChain,
  retriever,
});

const response = await retrievalChain.invoke({ input: "question" });

import { createRana } from '@rana/core';
import { createRAG } from '@rana/rag';

const rana = createRana();
const rag = createRAG({ rana });

await rag.ingest(text);

const response = await rag.query('question');