Q&A Bot (lagbot_qa)

┌─────────────────────────────────────────────────────────────┐
│                      User Interfaces                         │
│  ┌─────────────┐   ┌─────────────┐   ┌─────────────────┐   │
│  │  Telegram   │   │   Discord   │   │   Web Widget    │   │
│  └──────┬──────┘   └──────┬──────┘   └────────┬────────┘   │
│         │                 │                    │            │
└─────────┼─────────────────┼────────────────────┼────────────┘
          │                 │                    │
          └─────────────────┼────────────────────┘
                            │
                    ┌───────▼───────┐
                    │  LangChain    │
                    │  Agent Core   │
                    │               │
                    │ - Query Parse │
                    │ - Tool Select │
                    │ - Response    │
                    └───────┬───────┘
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
          ▼                 ▼                 ▼
   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐
   │   Vector    │  │  Knowledge  │  │   Tool      │
   │   Store     │  │   Graph     │  │   Actions   │
   │  (Towhee)   │  │   Query     │  │             │
   └─────────────┘  └─────────────┘  └─────────────┘

User Query: "What is the Florin token?"
    │
    ▼
┌─────────────────────────────────────┐
│  1. Query Embedding                  │
│     - Convert to vector (Towhee)     │
│     - Dimension: 768                 │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  2. Similarity Search                │
│     - Search vector store            │
│     - Top-k nearest neighbors (k=5)  │
│     - Filter by relevance threshold  │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  3. Context Assembly                 │
│     - Retrieve source documents      │
│     - Rank by relevance score        │
│     - Assemble context window        │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  4. Response Generation              │
│     - Prompt with context + query    │
│     - Generate response (GPT-3.5)    │
│     - Format for platform            │
└─────────────────────────────────────┘

from langchain.agents import AgentExecutor, create_react_agent
from langchain.memory import ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

class LagbotQA:
    def __init__(self, vector_store, tools):
        self.llm = ChatOpenAI(
            model="gpt-3.5-turbo",
            temperature=0.7
        )

        self.memory = ConversationBufferWindowMemory(
            memory_key="chat_history",
            k=10,  # Keep last 10 exchanges
            return_messages=True
        )

        self.tools = tools + [
            self._create_retrieval_tool(vector_store)
        ]

        self.agent = create_react_agent(
            llm=self.llm,
            tools=self.tools,
            prompt=self._create_prompt()
        )

        self.executor = AgentExecutor(
            agent=self.agent,
            tools=self.tools,
            memory=self.memory,
            verbose=True
        )

    async def query(self, user_input: str) -> str:
        """Process user query and return response"""
        result = await self.executor.ainvoke({
            "input": user_input
        })
        return result["output"]

    def _create_retrieval_tool(self, vector_store):
        """Create tool for knowledge retrieval"""
        from langchain.tools import Tool

        def search_knowledge(query: str) -> str:
            docs = vector_store.similarity_search(query, k=5)
            return "\n\n".join([doc.page_content for doc in docs])

        return Tool(
            name="knowledge_search",
            description="Search the fXYZ knowledge base for relevant information",
            func=search_knowledge
        )

from towhee import pipe, ops

class TowheePipeline:
    """ML pipeline for document embeddings using Towhee"""

    def __init__(self):
        # Embedding pipeline
        self.embed_pipe = (
            pipe.input('text')
            .map('text', 'vec', ops.sentence_embedding.sbert(
                model_name='all-MiniLM-L6-v2'
            ))
            .output('vec')
        )

        # Search pipeline
        self.search_pipe = (
            pipe.input('query', 'collection')
            .map('query', 'query_vec', ops.sentence_embedding.sbert(
                model_name='all-MiniLM-L6-v2'
            ))
            .flat_map(('query_vec', 'collection'), 'result',
                      ops.ann_search.milvus_client(
                          host='localhost',
                          port='19530'
                      ))
            .output('result')
        )

    def embed_documents(self, documents: list) -> list:
        """Generate embeddings for documents"""
        embeddings = []
        for doc in documents:
            result = self.embed_pipe(doc)
            embeddings.append(result.get())
        return embeddings

    def search(self, query: str, k: int = 5) -> list:
        """Search for similar documents"""
        results = self.search_pipe(query, 'knowledge_base')
        return results.get()[:k]

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters

class TelegramBot:
    def __init__(self, token: str, qa_agent: LagbotQA):
        self.app = Application.builder().token(token).build()
        self.qa = qa_agent

        # Register handlers
        self.app.add_handler(CommandHandler("start", self.start))
        self.app.add_handler(CommandHandler("help", self.help))
        self.app.add_handler(MessageHandler(
            filters.TEXT & ~filters.COMMAND,
            self.handle_message
        ))

    async def start(self, update: Update, context):
        await update.message.reply_text(
            "Welcome to Lagrange Q&A Bot! "
            "Ask me anything about the fXYZ ecosystem."
        )

    async def help(self, update: Update, context):
        await update.message.reply_text(
            "Commands:\n"
            "/start - Start conversation\n"
            "/help - Show this help\n\n"
            "Just type your question and I'll do my best to answer!"
        )

    async def handle_message(self, update: Update, context):
        user_query = update.message.text

        # Show typing indicator
        await update.message.chat.send_action("typing")

        # Get response from QA agent
        response = await self.qa.query(user_query)

        await update.message.reply_text(response)

    def run(self):
        self.app.run_polling()

// Modern Fixie chat using Vercel AI SDK
import { useChat } from '@ai-sdk/react';

function FixieChat({ agentId }: { agentId: string }) {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: `/api/fixie/${agentId}/stream`,
  });

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}: {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
      </form>
    </div>
  );
}

archive/fxyz-knowledge-project/old-projects/lagrange-repos/lagbot_qa-main/
├── src/
│   ├── agent/
│   │   ├── langchain_agent.py
│   │   └── tools.py
│   ├── embeddings/
│   │   ├── towhee_pipeline.py
│   │   └── vector_store.py
│   ├── integrations/
│   │   ├── telegram_bot.py
│   │   └── discord_bot.py
│   └── main.py
├── data/
│   ├── knowledge_base/
│   └── embeddings/
├── config/
│   └── settings.yaml
└── requirements.txt